PC World 2008 September/PCWorld_2008-09_cd.bin/v cisle/sadanastroju/delicious_bookmarks-2.0.64-fx.xpi/chrome/deliciousBookmarks.jar/content/ybookmarksOverlay.js

Text File | 2008-06-19 | 128.6 KB | 3,268 lines

var gYBRdfService     = Components.classes["@mozilla.org/rdf/rdf-service;1"].
                                getService(Components.interfaces.nsIRDFService);
var  gYBrscName       = gYBRdfService.GetResource( "http://home.netscape.com/NC-rdf#Name" );
var  gYBrscGenTitle   = gYBRdfService.GetResource( "http://home.netscape.com/NC-rdf#GeneratedTitle" );
var  gYBrscUrl        = gYBRdfService.GetResource( "http://home.netscape.com/NC-rdf#URL" );
var  gYBrscTagValue   = gYBRdfService.GetResource( "http://www.mozilla.org/bookmark#tagvalue" );
var  gYBrscTag        = gYBRdfService.GetResource( "http://www.mozilla.org/bookmark#tag" );
var  gYBrscVisitCount = gYBRdfService.GetResource( "http://home.netscape.com/NC-rdf#VisitCount" );
var  gYBrscLastVisitDate   = gYBRdfService.GetResource( "http://home.netscape.com/WEB-rdf#LastVisitDate" );
var  gYBrscBundle   = gYBRdfService.GetResource( "http://www.mozilla.org/bundles#Bundle" );
var  gYBrscBundleValue   = gYBRdfService.GetResource( "http://www.mozilla.org/bundles#BundleValue" );

// constants for cookie created by Delicious 2.0 XT
const DEL_COOKIE_NAME = 'FFDeliciousXT';
const DEL_COOKIE_URL = 'http://delicious.com/';
const DEL_COOKIE_DOMAIN = '.delicious.com';
const DEL_COOKIE_DATA = 'version=2.0';
const DEL_COOKIE_EXPIERE_AFTER_DAYS = 0; // create session cookie
const DEL_COOKIE_POST_REG = 'extReg';
const DEL_COOKIE_EXT_IMPORT = 'FFDeliciousXT_Import';

var gYBrscBundleRoot = gYBRdfService.GetResource("NC:YBookmarksBundleRoot");

const Y_kSyncServiceContractID = "@mozilla.org/ybookmarks-sync-service;1";
const Y_kDelContractID = "@yahoo.com/socialstore/delicious;1";

/* Regular expression used to get the toolbar folder from the bookmarks file. */
const Y_TOOLBAR_FOLDER_RE = new RegExp(
   "^.*<H3[^<>]*PERSONAL_TOOLBAR_FOLDER=\"true\"[^<>]*>([^<]*)</H3>.*$", "m");
/* Wait to be performed between sync attempts. */
const Y_SYNC_ATTEMPT_WAIT = 10 * 1000;
const Y_BOOKMARKS_INITIAL_IMPORT_POLLING_PERIOD = 5 * 1000;
const Y_BOOKMARKS_IMPORT_POLLING_PERIOD = 30 * 1000;

// Default threshold to hide the MyTags menu popup in the main menu
const Y_DEFAULT_BOOKMARKS_THRESHOLD = 2000;

const YB_MENUITEM_NOICON = "menuitem yb_menuitem_noicon";
var gPrefsWindow = null;

var ybookmarksMain = {
   initialized: false,
   gBookmarks: null,
   syncservice: null,
   strings: null,
   prefs: null,
   isNewTagAdded: false,
   isBookmarkChanged: true,
   isChangingDatasource : false,
   _is_frequent_menu_update_required: true,
   _is_recent_menu_update_required: true,
   _is_recently_saved_menu_update_required: true,

   _bookmarkRdfObserver: null,


  // _tagsToolbarMenuDatasource: null,

   /*
   _popular_tag_menus: [ "ybookmarks_tags_menu_1", "ybookmarks_tags_menu_2",
                         "ybookmarks_tags_menu_3", "ybookmarks_tags_menu_4",
                         "ybookmarks_tags_menu_5"
                       ],
   */

   onLoad: function() {
      yDebug.print("Loading ybookmarks");

      // remove the listener first
      window.removeEventListener( "load", yb_onLoad, false );

      /**
       * Hack for managing inconsistancy of bookmarks menu id ->> 2.* "bookmarks-menu" 3.* "bookmarksMenu"
       */
      var bookmarksMenuId = "";

      if(ybookmarksUtils.getFFMajorVersion() > 2) {
          bookmarksMenuId = "bookmarksMenu";
      }
      else {
          bookmarksMenuId = "bookmarks-menu";
      }

      this.gBookmarks = Components.classes["@mozilla.org/ybookmarks-store-service;1"].
          getService(Components.interfaces.nsIYBookmarksStoreService);

      //register the sync service
      this.syncservice =
            Components.classes[Y_kSyncServiceContractID].
               getService(Components.interfaces.nsIYBookmarkSyncService);


      // hide only if user requests
      this.prefs = Components.classes["@mozilla.org/preferences-service;1"]
                      .getService(Components.interfaces.nsIPrefBranch);

      var hideFFBMMenu = false;
      try {
        hideFFBMMenu = this.prefs.getBoolPref("[e-mail]");
      } catch ( e ) { }
      // we put this here because there's some lag with the ui hiding,
      // but we're safe to hide the bookmarks menu immediately
      var bookmarksMenu = document.getElementById(bookmarksMenuId);
      if (bookmarksMenu) {
        if(!ybookmarksUtils.isOSXLeopard()) {
            bookmarksMenu.setAttribute('hidden', hideFFBMMenu);
        }
      }

      // initialization code
      this.initialized = true;
      this.strings = document.getElementById("ybookmarks-strings");

      /* register extension uninstall/disable observer. */
      yUninstallObserver.register();

      ybContextMenu.register();

      ybUserInterface.register();

      /* Only do these if we have a visible toolbar */
      if (window.toolbar.visible || window.menubar.visible || window.locationbar.visible) {
      /*  var tagsMenu = document.getElementById( "ybookmarks_tags_1" );
        tagsMenu.database.AddDataSource( this.gBookmarks.getDataSource() );
        tagsMenu.builder.rebuild();
        */
        // add popupshowing event handler for feed-button.
        // This is needed to prevent the addBookmarks dialog appearning for the RSS feeds.
        // document.getElementById( "feed-button" ).addEventListener( "command", function(e) { yDebug.print( "In Feed Handler" ); e.preventBubble(); e.preventDefault(); return false; }, true );
        try {
        document.getElementById( "bookmark-sort-tree" ).database.
                    AddDataSource( this.gBookmarks.getDataSource() );
        document.getElementById( "bookmark-tags-tree" ).database.
                    AddDataSource( this.gBookmarks.getDataSource() );
        } catch (e) {
          yDebug.print(e, YB_LOG_MESSAGE);
        }
        //this._bookmarkRdfObserver = new ybBookmarkMenuUpdater( tagsMenu );

        var del = Components.classes[Y_kDelContractID].getService( Components.interfaces.nsISocialStore );
        var username = del.getUserName();
        yDebug.print ( "User Name => " + username );
        if (username == null || username.length == 0) {
           yDebug.print ("No username found", YB_LOG_MESSAGE);
        } else {
           yDebug.print ("Username found", YB_LOG_MESSAGE);
        }
        yDebug.print ( "Login URL => " + del.login_url );
        yDebug.print ( "Register URL => " + del.register_url );
        yDebug.print ( "Service Name => " + del.service_name );

        var os = Components.classes["@mozilla.org/observer-service;1"]
                                     .getService(Components.interfaces.nsIObserverService);
/*        os.addObserver ( this._bookmarkRdfObserver, "ybookmark.syncBegin", false );
        os.addObserver ( this._bookmarkRdfObserver, "ybookmark.syncDone", false );*/
        os.addObserver( YbookmarkUpdateObserver, "ybookmark.syncBegin", false );
        os.addObserver( YbookmarkUpdateObserver, "ybookmark.syncInfo", false );
        os.addObserver( YbookmarkUpdateObserver, "ybookmark.syncDone", false );
        os.addObserver( YbookmarkUpdateObserver, "ybookmark.forceRefresh", false );

        os.addObserver ( this._importBookmarksObserver, "ybookmark.importBookmarks", false);
        os.addObserver ( this._disableExtensionObserver, "ybookmark.disableExtension", false);
        os.addObserver ( this._addBookmarkObserver, "ybookmark.addBookmark", false);
        os.addObserver ( yAddBookMark.bookmarkTransactionsObserver, "ybookmark.processTransactions", false);
        os.addObserver ( this._errorObserver, "ybookmark.serverError", false);
        os.addObserver( this._cookieObserver, "cookie-changed", false );

        yAddBookMark.addHooks();

        // 2007-01-24 cmyang: for some reason, we need to put this here. something with timing initializing the DOM key bindings.
        // currently, when we remap the keys, we need to open the bookmarks and del menu
        // which seems to reload the actual keybindings (opening a new window will work too).  Putting the call here probably makes
        // the changes prior to the initial DOM initialization
        //var classic = false;
        //:::Classic

        var menu = window.document.getElementById("ybookmarks_menu_popup");
        var optionsMenu = window.document.getElementById("deliciousOptions");
        if(ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_CLASSIC)  {
            ybUserInterface.tweakKeyBindings(false);
            //:::Classic:::
            ybookmarksMain.showSpecialChildMenu(menu, "yb_classic_only");
            //Tools->Options menu
            if(optionsMenu) {
                optionsMenu.hidden = true;
            }
        } else {
            var remapKeyBindings = false;
            try {
              remapKeyBindings = this.prefs.getBoolPref("[e-mail]");
            } catch (e) {}
            ybUserInterface.tweakKeyBindings(remapKeyBindings);
            //:::Classic:::Show all standard mode menu icons
            ybookmarksMain.showSpecialChildMenu(menu, "yb_std_mode_only");
            //Tools->Options menu
            if(optionsMenu) {
                optionsMenu.hidden = false;
            }
        }
        os.addObserver( YBidManager, "ybookmark.userChanged", false);
        ybookmarksMain.setLoginState();
      }

      //ybInfoPanel.register();

      // hack for making the vetical alignment of the nav-bar buttons the right size
      // 1.5 icons+text, icons are 32x32.
      // 2.0 icons+text, icons are 24x24.
      var appInfo = Components.classes["@mozilla.org/xre/app-info;1"]
                  .getService(Components.interfaces.nsIXULAppInfo);
      var versionChecker = Components.classes["@mozilla.org/xpcom/version-comparator;1"]
                               .getService(Components.interfaces.nsIVersionComparator);
      if(versionChecker.compare(appInfo.version, "1.5") == 0) {
        var btnDel = document.getElementById("del-button-delicious");
        var btnTag = document.getElementById("del-button-tagPage");
        if (btnDel) {
          btnDel.setAttribute("class", btnDel.getAttribute("class") + " firefox15");
            btnTag.setAttribute("class", btnTag.getAttribute("class") + " firefox15");
          }
      }

      //check for the first time start
      // allow the rest of fx to comeup before we attempt this
      setTimeout(function() {
                    try {
                       ybookmarksMain._delayedLoad();
                    } catch (e) {
                       yDebug.print("Uncaught error during _delayedLoad:"
                                    + e.message + (e.stack ? e.stack : ""),
                                    YB_LOG_MESSAGE);
                       throw e;
                    }
                 }, 250);

    this.checkUserLoggedInState();
    //Show Delicious menu on Normal Mode.
    if(ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_STANDARD)  {
        var ybMainDelMenu = document.getElementById("yb_menu");
        if(ybMainDelMenu) {
            ybMainDelMenu.setAttribute('hidden', 'false');
        }
    }


      if(ybookmarksUtils.getFFMajorVersion() > 2) {
          try {
          //Listen for webpage loads
          gBrowser.addProgressListener(urlBarListenerFavIcon, Components.interfaces.nsIWebProgress.NOTIFY_ALL);

          /**
           * This hack is added to ask for delicious post after adding new bookmark
           */
            PlacesCommandHook.bookmarkPage = function PCH_bookmarkPage(aBrowser, aParent, aShowEditUI) {

                var uri = aBrowser.currentURI;
                var itemId = PlacesUtils.getMostRecentBookmarkForURI(uri);
                if (itemId == -1) {
                    // Copied over from addBookmarkForBrowser:
                    // Bug 52536: We obtain the URL and title from the nsIWebNavigation
                    // associated with a <browser/> rather than from a DOMWindow.
                    // This is because when a full page plugin is loaded, there is
                    // no DOMWindow (?) but information about the loaded document
                    // may still be obtained from the webNavigation.
                    var webNav = aBrowser.webNavigation;
                    var url = webNav.currentURI;
                    var title;
                    var charset;
                    var description;
                    try {
                        title = webNav.document.title || url.spec;
                        charset = webNav.document.characterSet;
                        description = PlacesUtils.getDescriptionFromDocument(webNav.document);
                    }
                    catch (e) { }

                    if (aShowEditUI) {
                        // If we bookmark the page here (i.e. page was not "starred" already)
                        // but open right into the "edit" state, start batching here, so
                        // "Cancel" in that state removes the bookmark.
                        StarUI.beginBatch();
                    }

                    try {
                      var parent = aParent != undefined ?
                                   aParent : PlacesUtils.unfiledBookmarksFolderId;
                      var descAnno = { name: DESCRIPTION_ANNO, value: description };
                      var txn = PlacesUIUtils.ptm.createItem(uri, parent, -1,
                                                             title, null, [descAnno]);
                      PlacesUIUtils.ptm.doTransaction(txn);
                      // Set the character-set
                      if (charset)
                        PlacesUtils.history.setCharsetForURI(uri, charset);
                      itemId = PlacesUtils.getMostRecentBookmarkForURI(uri);
                    }
                    catch(e) {
                        yDebug.print("ybookmarksOverlay.js::Onload():: Exception - "+e, YB_LOG_MESSAGE);
                    }
                    /**
                       * Ask if user wants to add this item to delicious
                       */
                    var prefs = Components.classes["@mozilla.org/preferences-service;1"].
                      getService(Components.interfaces.nsIPrefBranch);

                    var remindCheck = prefs.getBoolPref("[e-mail]");
                    if (remindCheck) {
                      var strings = document.getElementById("ybookmarks-strings");
                      var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].
                                            getService(Components.interfaces.nsIPromptService);

                      var cnfTitle = strings.getString("extensions.ybookmarks.original.add.dialog.hook.title");
                      var cnfText = strings.getString("extensions.ybookmarks.original.add.dialog.hook.text");
                      var cnfRemind = strings.getString("extensions.ybookmarks.original.add.dialog.hook.remind");
                      remindCheck = { value: true };
                      var promptFlags = (promptService.BUTTON_TITLE_NO * promptService.BUTTON_POS_0) +
                                        (promptService.BUTTON_TITLE_YES * promptService.BUTTON_POS_1) +
                                        promptService.BUTTON_POS_1_DEFAULT;

                      var addToDel = promptService.confirmEx(this, cnfTitle, cnfText, promptFlags, "", "", "", cnfRemind, remindCheck);

                      if (!remindCheck.value) {
                        prefs.setBoolPref("[e-mail]", false);
                      }

                      if (addToDel == 1) {
                        //url, title, charset, isWebPanel, notes, feedUrl, blankEntry, postData, keywordInput
                          yAddBookMark.open(url.spec, title, charset, false, description);
                      }
                    }
                }

                // Revert the contents of the location bar
                handleURLBarRevert();

                // dock the panel to the star icon when possible, otherwise dock
                // it to the content area
                if (aBrowser.contentWindow == window.content) {
                  var starIcon = aBrowser.ownerDocument.getElementById("star-button");
                  if (starIcon && isElementVisible(starIcon)) {
                    if (aShowEditUI)
                      StarUI.showEditBookmarkPopup(itemId, starIcon, "after_end");
            //@line 419 "/e/fx19rel/WINNT_5.2_Depend/mozilla/browser/base/content/browser-places.js"
                    return;
                  }
                }
                StarUI.showEditBookmarkPopup(itemId, aBrowser, "overlap");
              }
          }
          catch(e) {
              yDebug.print("ybookmarksOverlay.js::Onload():: Exception - "+e, YB_LOG_MESSAGE);
          }
      }

      yDebug.print("Done loading ybookmarks", YB_LOG_MESSAGE);
   },

   showSpecialChildMenu: function(menu, attribute) {
        for(i = 0; i < menu.childNodes.length; ++i ) {
            val = ( menu.childNodes[ i ] ).getAttribute( attribute );
            if( val && ( val == "true" ) ) {
                ( menu.childNodes[ i ] ).hidden = false;
            }
           }
   },

   onUnload: function() {
     this.gBookmarks.flush(true);
     ybContextMenu.unregister();
  /*   try {
       ybookmarksMain.gBookmarks.getDataSource().RemoveObserver( ybookmarksMain._bookmarkRdfObserver );
     } catch ( e ) { }
*/
     try {
       this.prefs.removeObserver( "", YBonMenuTypePrefChanged );
     } catch ( e ) { }
     var os = Components.classes["@mozilla.org/observer-service;1"]
                                     .getService(Components.interfaces.nsIObserverService);
     try {
  /*     os.removeObserver ( this._bookmarkRdfObserver, "ybookmark.syncBegin" );
       os.removeObserver ( this._bookmarkRdfObserver, "ybookmark.syncDone" );*/
       os.removeObserver ( YbookmarkUpdateObserver, "ybookmark.syncBegin" );
       os.removeObserver ( YbookmarkUpdateObserver, "ybookmark.syncInfo" );
       os.removeObserver ( YbookmarkUpdateObserver, "ybookmark.syncDone" );
       os.removeObserver ( YbookmarkUpdateObserver, "ybookmark.forceRefresh");

       os.removeObserver ( this._importBookmarksObserver, "ybookmark.importBookmarks");
       os.removeObserver ( this._disableExtensionObserver, "ybookmark.disableExtension");
       os.removeObserver ( this._addBookmarkObserver, "ybookmark.addBookmark");
       os.removeObserver ( yAddBookMark.bookmarkTransactionsObserver, "ybookmark.processTransactions");
       os.removeObserver ( this._errorObserver, "ybookmark.serverError");
       os.removeObserver ( YBidManager, "ybookmark.userChanged");
       os.removeObserver( this._cookieObserver, "cookie-changed");
      if(ybookmarksUtils.getFFMajorVersion() > 2) {
       //Clear listen for webpage loads
       gBrowser.removeProgressListener(urlBarListenerFavIcon);
      }
     }
     catch (e) { }

     try {
       //ybInfoPanel.unregister();
     } catch (e) { }

     try {
       yUninstallObserver.unregister();
     } catch ( e ) {
     }

     ybUserInterface.unregister();

   },

   postRegCookiePresent : function() {
           var cookieManager = ( Components.classes[ "@mozilla.org/cookiemanager;1" ]
                                           .getService( Components.interfaces.nsICookieManager ) );
         var iter = cookieManager.enumerator;
         while( iter.hasMoreElements() ) {
            var cookie = iter.getNext();
            if( cookie instanceof Components.interfaces.nsICookie ) {
                   if(cookie.host == DEL_COOKIE_DOMAIN && cookie.name == DEL_COOKIE_POST_REG) {
                  yDebug.print( "ybookmarksOverlay.js:: postReg cookie found", YB_LOG_MESSAGE );
                  return true;
                   }
            }
         }
         return false;
   },

   addToolbarButtons : function() {
        var toolbox = document.getElementById("navigator-toolbox");
        var toolboxDocument = toolbox.ownerDocument;

        var hasDeliciousButton = false, hasTagPageButton = false, hasDeliciousPageButton = false;

        for (var i = 0; i < toolbox.childNodes.length; ++i) {
            var toolbar = toolbox.childNodes[i];

            if (toolbar.localName == "toolbar"
                && toolbar.getAttribute("customizable")=="true") {

               if(toolbar.currentSet.indexOf("del-button-delicious") > -1)
                  hasDeliciousButton = true;
               if(toolbar.currentSet.indexOf("del-button-tagPage")>-1)
                  hasTagPageButton = true;
               if(toolbar.currentSet.indexOf("del-button-delicious-page") > -1)
                     hasDeliciousPageButton = true;
            }
        }

        if(!hasDeliciousButton || !hasTagPageButton || !hasDeliciousPageButton) {
            var toolbar = document.getElementById("nav-bar");

            var newSet = "";
            var child = toolbar.firstChild;
            while(child){
                //Order of buttons is important
                if(!hasDeliciousPageButton && child.id == "urlbar-container") {
                    newSet += "del-button-delicious-page,";
                    hasDeliciousPageButton = true;
                }

                if(!hasDeliciousButton
                        && (child.id=="del-button-tagPage"
                        || child.id=="urlbar-container")) {
                    newSet += "del-button-delicious,";
                    //yDebug.print("ybookmarksOverlay.js::ybookmarksMain::addToolbarButtons()=> Adding delicious button", YB_LOG_MESSAGE);
                    hasDeliciousButton = true;
                }

                if(!hasTagPageButton && child.id=="urlbar-container") {
                    newSet += "del-button-tagPage,";
                    hasTagPageButton = true;
                }

                newSet += child.id+",";
                child = child.nextSibling;
            }

            newSet = newSet.substring(0, newSet.length-1);
            toolbar.currentSet = newSet;
            toolbar.setAttribute("currentset", newSet);
            toolboxDocument.persist(toolbar.id, "currentset");
            try {
                BrowserToolboxCustomizeDone(true);
            } catch (e) {
                /* protect against future change */
            }
        }
   },

   upgradeFrom1_5 : function() {
        var toolbar = document.getElementById("nav-bar");
        var newSet = "";
        //yDebug.print("Current set:" + toolbar.currentSet, YB_LOG_MESSAGE);
        var currButtons = toolbar.currentSet.split(",");
        for( x in currButtons) {
            var cur = currButtons[x];
            if((cur != "del-button-tagPage") && (cur != "del-button-delicious")) {
                if(cur == "urlbar-container") {
                    newSet += "del-button-delicious-page,del-button-delicious,del-button-tagPage," + currButtons[x] + ",";
                } else {
                    newSet += currButtons[x] + ",";
                }
            }
        }
        newSet = newSet.substring(0, newSet.length-1);
        toolbar.currentSet = newSet;
        toolbar.setAttribute("currentset", newSet);
        toolboxDocument.persist(toolbar.id, "currentset");
        try {
            BrowserToolboxCustomizeDone(true);
        } catch (e) {
            /* protect against future change */
        }
   },

   firstTimeStart : function() {
       yDebug.print("ybookmarksOverlay.js::ybookmarksMain::firstTimeStart()=> Invoked", YB_LOG_MESSAGE);
     try {
      var currentVersionNum = this.strings.getString("extensions.ybookmarks.versionNum");
      yDebug.print("ybookmarksOverlay.js::ybookmarksMain::firstTimeStart()=> Version being installed = "
          +currentVersionNum, YB_LOG_MESSAGE);
      var newInstall        = false;
      var upgraded          = false;
      var upgradedFrom1_3   = false;
      var upgradedFromOlderthan2_0_58 = false;
      try{
          //This will throw an exception for fresh install and in turn set the version number in prefs.
         var num = this.prefs.getCharPref("[e-mail]");

         if(num != currentVersionNum){
            this.prefs.setCharPref("[e-mail]",
                                   currentVersionNum);
            yDebug.print("ybookmarksOverlay.js::ybookmarksMain::firstTimeStart()=> Install Type = Upgrade",
                YB_LOG_MESSAGE);
            upgraded = true;
         }
         var versionChecker = Components.classes["@mozilla.org/xpcom/version-comparator;1"]
            .getService(Components.interfaces.nsIVersionComparator);
         //The first version of the extn with two store impl
         if (versionChecker.compare(num, "1.4.00") < 0) {
            upgradedFrom1_3 = true;
         }
         if (versionChecker.compare(num, "2.0.58") < 0) {
            upgradedFromOlderthan2_0_58 = true;
         }

      } catch(e){
         this.prefs.setCharPref("[e-mail]",
                                currentVersionNum);
         ybToolbar.firstTimeStart();
         newInstall = true;
         yDebug.print("ybookmarksOverlay.js::ybookmarksMain::firstTimeStart()=> Install Type = New Install",
             YB_LOG_MESSAGE);
      }

      if(newInstall || upgraded) {

        if (newInstall) {
            //Force open sidebar on new install only.
            setTimeout(function() { toggleSidebar('viewYBookmarksSidebar', true); }, 100);
        }

        //Add the toolbar buttons forcefully on upgrade from version < 2.0.58.
        if(newInstall) {
            this.addToolbarButtons();
        } else if(upgradedFromOlderthan2_0_58) {
            //Forcefully add buttons in correct order.
            this.upgradeFrom1_5();
        }

        //Open tour url
        var postRegCookie = this.postRegCookiePresent();
        if(upgraded || (newInstall && !postRegCookie)) {
        setTimeout(function(aUrl) {
                       var browser = document.getElementById("content");
                       var tab = browser.addTab(aUrl);
                       browser.selectedTab = tab;
                      },
                      100,
                      deliciousService.getQuickTourUrl()
                   );
        }
      }

      if (upgradedFrom1_3) {
        // popup an informative alert for those upgrading
        try {
          setTimeout(function() { ybookmarksMain.doUpgradeFor1_3(); }, 250);
        } catch (e) {
          yDebug.print("error with upgrade 1.3 popup: " + e, YB_LOG_MESSAGE);
        }

      }

  } catch (e) {
    yDebug.print("firstTimeStart(): " + e, YB_LOG_MESSAGE);
  }
  },

  doUpgradeFor1_3: function() {
    try {
        var showBookmarkMenu = {};

        /**
         * Show UI hide dialog only for FF below 3.x and set original.ui.hide to false for greater versions
         */
        if(ybookmarksUtils.getFFMajorVersion() < 3) {
            openDialog("chrome://ybookmarks/content/upgradeAlertFrom1_3.xul", "upgradeAlert", "chrome,modal=yes,centerscreen", showBookmarkMenu);
        }
        else {
            showBookmarkMenu.value = true;
        }

        try {
          this.prefs.setBoolPref("[e-mail]", showBookmarkMenu.value == false);
        } catch (e) {
          yDebug.print("upgrading 1.3: error with setting ui preference: " + e, YB_LOG_MESSAGE);
        }

        //copy over the favorite tags from extra.rdf
        try {
        this._copyFavoriteTagsToTwoStore();
      } catch (e) {
        yDebug.print("upgrading 1.3: error with copying over favorite tags: " + e, YB_LOG_MESSAGE);
      }
      //last run version is older than the two-store version. restore bookmarks
      yDebug.print("Attempting to restore old bookmarks", YB_LOG_MESSAGE);
      try {
        var ds = Components.classes["@mozilla.org/file/directory_service;1"]
            .createInstance(Components.interfaces.nsIProperties);
        var yBackup = ds.get("ProfD", Components.interfaces.nsIFile);
        yBackup.append("bk_bookmarks.html");
        if (yBackup.exists()) {
            var currentTime = (new Date()).getTime();

            var yOrigBookmarks = ds.get("ProfD",
                                        Components.interfaces.nsIFile);
            yOrigBookmarks.append("bookmarks.html");
            if (yOrigBookmarks.exists()) {
               yOrigBookmarks.copyTo(null,
                                     "upg_bookmarks_" + currentTime + ".html");
            }


            //based on FF version call relevant function
            if(ybookmarksUtils.getFFMajorVersion() > 2) {
                yb_restoreBookmarksToPlaces(yBackup);
            }
            else {
                yb_restoreBookmarks(yBackup);
            }


            yBackup.moveTo(null, "bk_bookmarks_" + currentTime + ".html");

            yDebug.print("Restored old bookmarks", YB_LOG_MESSAGE);
        }
      } catch (e) {
        yDebug.print("upgrading 1.3: error with restoring old bookmarks: " + e, YB_LOG_MESSAGE);
      }

      //remove any persisted column orderings in the bookmark manager
      // this is to ensure our default import column order
      try {
          var localstore  = Components.classes["@mozilla.org/rdf/datasource;1?name=local-store"].
                              getService(Components.interfaces.nsIRDFDataSource);
        var manRsrc     = gYBRdfService.GetResource("chrome://browser/content/bookmarks/bookmarksManager.xul#bookmarks-view");
        var colinfoRsrc = gYBRdfService.GetResource("colinfo");

        var colinfo = localstore.GetTarget(manRsrc, colinfoRsrc, true);
        if (colinfo) {
          localstore.Unassert(manRsrc, colinfoRsrc, colinfo);
        }
      } catch (e) {
        yDebug.print("error removing colinfo property from the bookmark manager: " + e, YB_LOG_MESSAGE);
      }

      toggleSidebar('viewYBookmarksSidebar', true)

    } catch (e) {
      yDebug.print("ybookmarksMain.showUpgradeAlert1_3(): " + e, YB_LOG_MESSAGE);
    }

  },

   _delayedLoad: function() {
      yDebug.print("Delayed load start ybookmarks");

      var pt = document.getElementById("PersonalToolbar"); // the old Bookmark Toolbar.  This is a check to see if we;re in the main overlay, and not some peon dialog
      if (pt) {
          var hideFFBMMenu = false;
          var remapKeyBindings = false;
          try {
            hideFFBMMenu = this.prefs.getBoolPref("[e-mail]");
          } catch ( e ) { }
          ybUserInterface.tweakBookmarksUI(hideFFBMMenu);
      }

      var wm =
         Components.classes["@mozilla.org/appshell/window-mediator;1"].
            getService(Components.interfaces.nsIWindowMediator);
      var winEnumerator = wm.getEnumerator("navigator:browser");
      /* this guarantees that having multiple windows won't cause problems. */
      var isFirstWindow = (winEnumerator.getNext() == window);
      if (isFirstWindow) {
         var incompatibleExts = yDisableExtensions.getIncompatibleExtensions();

         if (incompatibleExts.foundList.length > 0) {
            window.openDialog(
               "chrome://ybookmarks/content/yDisableExtensions.xul",
               "disable-extensions-dialog", "chrome,dialog,modal,centerscreen",
               incompatibleExts.foundList);
            return;
         }
         // warn user to enable cookies.
         confirmEnableCookies();
         if (!this.isEngineInstalled()) {
            if (!this.installEngine()) {
                return;
            }
         }
      }

      // Create delicious XT session cookie
      /*
        ybookmarksUtils.setCookie(DEL_COOKIE_NAME, DEL_COOKIE_URL, DEL_COOKIE_DOMAIN,
             DEL_COOKIE_DATA, DEL_COOKIE_EXPIERE_AFTER_DAYS);         */

      // add the observer to change the status bar message during the update
      /* Only do these if we have visible toolbar */
      if (window.toolbar.visible || window.menubar.visible || window.locationbar.visible) {
        // Add observer for the preference
        this.prefs.addObserver( "", YBonMenuTypePrefChanged, false );
  /*      var tagsMenu = document.getElementById( "ybookmarks_tags_1" );

        // Add observer to the datasource
        ybookmarksMain.gBookmarks.getDataSource().AddObserver( this._bookmarkRdfObserver );
*/
      }

      //Show sidebar on a mode change to classic
      try {
         var loadSidebar = this.prefs.getBoolPref("[e-mail]");
         if(loadSidebar) {
             toggleSidebar('viewYBookmarksSidebar', true);
             this.prefs.setBoolPref("[e-mail]", false);
         }
      } catch(e) {}

      setTimeout(function() {
                    try {
                       ybookmarksMain._delayedLoad2();
                    } catch (e) {
                       yDebug.print("Uncaught error during _delayedLoad2:"
                                    + e.message,
                                    YB_LOG_MESSAGE);
                       throw e;
                    }
                 }, 1500);
    },

    /* begin the sync.  we delay this so that the localstore can be written out first */
    _delayedLoad2: function() {
      if (this.isEngineInstalled()) {

         //only run the syn on the first browser window and active the syn in
         // the hidden window
         var wm =
            Components.classes["@mozilla.org/appshell/window-mediator;1"].
               getService(Components.interfaces.nsIWindowMediator);
         var enumerator = wm.getEnumerator("navigator:browser");
         var counter = 0;

         while (enumerator.hasMoreElements()) {
            enumerator.getNext();
            counter++;
         }

         var del = Components.classes[Y_kDelContractID].getService( Components.interfaces.nsISocialStore );
         var username  = del.getUserName();
         if (username) {

           if (counter < 2) {
             this.syncservice.sync(true);
           }
           //Removing import status check on restart.
           //this._checkBookmarkImportPolling();
         }

        /*
        // If there is no update from delicious, callback in not done. Bookmark menu is not populated.
        // Will have to get some return value from sync call. For the time being, call the syncDone again.
        //bookmarkSyncCallback.syncDone();

        var bookmarkSyncCallback = {

          syncDone: function() {

            if ( ybookmarksMain._is_recent_menu_update_required ) {
              ybookmarks_Main.addBookmarksToPopup(
                                document.getElementById( "ybookmarks_rc_visited_pop" ),
                                "bookmark-sort-tree-visitdate-col" );
              ybookmarksMain._is_recent_menu_update_required = false;
            }
            if ( ybookmarksMain._is_frequent_menu_update_required ) {
              ybookmarks_Main.addBookmarksToPopup(
                                document.getElementById( "ybookmarks_fr_visited_pop" ),
                                "bookmark-sort-tree-visitcount-col" );
              ybookmarksMain._is_frequent_menu_update_required = false;
            }

            ybookmarks_Main.addBookmarkItemsToMainMenu();
          }
        };
        */

        /*
        for ( var index in this._popular_tag_menus ) {
          document.getElementById( this._popular_tag_menus[index]).database.
                          AddDataSource ( this.gBookmarks.getDataSource() );
        }
        */

        /*
        for ( var index in this._bag_menus ) {
          document.getElementById( this._bag_menus[index]).database.
                          AddDataSource ( this.gBookmarks.getDataSource() );
        }
        */

        /*
        document.getElementById( "ybookmarks-feed-menu" ).database.
                          AddDataSource ( this.gBookmarks.getDataSource() );
        */

        //this._buildTagsToolbarMenu();

      }

      this.checkUserLoggedInState();
      yDebug.print("Delayed load done ybookmarks", YB_LOG_MESSAGE);

   },

   /*
    * Copy the old Favorite Tags from extra.rdf
    * We keep the resources hardcoded because this is a backwards compatability function,
    * and all the "history" should remain local to the function
    */
   _copyFavoriteTagsToTwoStore: function() {
    try {
      yDebug.print("COPYING FAVORITE TAGS TO TWOSTORE");
        var extraFile = ybookmarksUtils.getProfileDir();
        extraFile.append("extra.rdf");
        if (!extraFile.exists()) {
          return;
        }
        var networkProtocol = Components.classes["@mozilla.org/network/protocol;1?name=file"].
           createInstance(Components.interfaces.nsIFileProtocolHandler);
      var extraURI = networkProtocol.newFileURI(extraFile).spec;
      var extra = Components.classes["@mozilla.org/rdf/datasource;1?name=xml-datasource"].
                    createInstance(Components.interfaces.nsIRDFRemoteDataSource);
        extra.QueryInterface(Components.interfaces.nsIRDFDataSource);
        try {
           extra.Init(extraURI);
         } catch (e) {
             yDebug.print("Error in initializing extra.rdf: " + e);
         }

         try {
           extra.Refresh(true);
         } catch (e) {
             yDebug.print("Error in refreshing extra.rdf: " + e);
         }

         var conUtils = Components.classes["@mozilla.org/rdf/container-utils;1"].
                            getService(Components.interfaces.nsIRDFContainerUtils);
         var favTagRoot = conUtils.MakeSeq(extra, gYBRdfService.GetResource("NC:YBookmarksFavoriteTagsRoot"));
         var favTagEnum = favTagRoot.GetElements();
         var favTagValueRsrc = gYBRdfService.GetResource("http://www.mozilla.org/bookmark#favoriteTagValue");
         var favTagOrderRsrc = gYBRdfService.GetResource("http://www.mozilla.org/bookmark#favoriteTagOrder");

         while (favTagEnum.hasMoreElements()) {
           var favTagRsrc = favTagEnum.getNext().QueryInterface(Components.interfaces.nsIRDFResource);
           var nameRsrc = null;
           var orderRsrc = null;

           nameRsrc = extra.GetTarget(favTagRsrc, favTagValueRsrc, true);
           if (!nameRsrc) {
             yDebug.print("Favorite Tag resource " + favTagValueRsrc + " missing favtag value");
             continue;
           }
           nameRsrc.QueryInterface(Components.interfaces.nsIRDFLiteral);
           var name = nameRsrc.Value;
         var order = null;

           orderRsrc = extra.GetTarget(favTagRsrc, favTagOrderRsrc, true);
           if (orderRsrc) {
             orderRsrc.QueryInterface(Components.interfaces.nsIRDFLiteral);
             order = orderRsrc.Value;
           } else {
             yDebug.print("Favorite Tag resource " + favTagValueRsrc + "(" + name + ") missing order value. using default");
           order = FAVTAGS_ORDER_DEFAULT;
           }
         this.gBookmarks.addFavoriteTag(name);
         this.gBookmarks.setFavoriteTagOrder(name, order);
         }
       ybToolbar.refreshCurrentView();
    } catch (e) {
      yDebug.print("_copyFavoriteTagsToTwoStore(): " + e, YB_LOG_MESSAGE);
    }
   },

   isBookmarkImportPolling: function() {
     if (!this.prefs.prefHasUserValue("[e-mail]")) {
       this.prefs.setBoolPref("[e-mail]", false);
     }
    return this.prefs.getBoolPref("[e-mail]");

   },

   setBookmarkImportPolling: function(polling) {
     this.prefs.setBoolPref("[e-mail]", polling);
    },

    _startImportAfterPolling: function(cookie) {
        var callback = {
        _ybookmarksMain: null,
        _cookie: null,

        onload: function(result) {
           yDebug.print("ybookmarksOverlay.js::_startImportAfterPolling=> Import status check onload", YB_LOG_MESSAGE);
           var propertyBag = result.queryElementAt(0, Components.interfaces.nsIPropertyBag);
           var status = propertyBag.getProperty("status");
           var strings = document.getElementById("ybookmarks-strings");
           yDebug.print("ybookmarksOverlay.js::_startImportAfterPolling=> Import status is :" + status, YB_LOG_MESSAGE);
           //"complete", "importing" or "failed"
           if (status == "importing") {
                  //Show MessageBox.
                  var promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].
                       getService(Components.interfaces.nsIPromptService);
                var title = strings.getString("extensions.ybookmarks.product.name");
                var text = strings.getString("extensions.ybookmarks.import.already.running");
                promptService.alert(this, title, text);
           } else {
               this._ybookmarksMain._importBookmarks(this._cookie);
           }
        },
        onerror: function(result) {
            yDebug.print("ybookmarksOverlay.js::_startImportAfterPolling=> Import status check failed", YB_LOG_MESSAGE);
        }
      };

      var ssr = Components.classes["@yahoo.com/socialstore/delicious;1"].
              getService(Components.interfaces.nsISocialStore);
      callback._ybookmarksMain = this;
      callback._cookie = cookie;
      ssr.getImportStatus(callback);

    },

   _checkBookmarkImportPolling: function() {
     var callback = {
        _ybookmarksMain: null,

        onload: function(result) {
           var propertyBag = result.queryElementAt(0, Components.interfaces.nsIPropertyBag);
           var status = propertyBag.getProperty("status");
           //"complete", "importing" or "failed"
           if (status == "importing") {
                this._ybookmarksMain.setBookmarkImportPolling(true);
                 setTimeout(function() {
                             var ssr = Components.classes["@yahoo.com/socialstore/delicious;1"].
                               getService(Components.interfaces.nsISocialStore);
                             ssr.getImportStatus(ybookmarksUtils.importStatusCallback); },
                           Y_BOOKMARKS_INITIAL_IMPORT_POLLING_PERIOD);
               }

        },
        onerror: function(event) {
        }
      };

      var ssr = Components.classes["@yahoo.com/socialstore/delicious;1"].
              getService(Components.interfaces.nsISocialStore);
      callback._ybookmarksMain = this;
      ssr.getImportStatus(callback);
   },

   onBookmarksMenuPopupShowing: function(event) {

         if(ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_CLASSIC)  {
             //:::Classic, we dont need this menu option.
             return true;
         }

      var popup = event.target;
      var hideThisMenu = document.getElementById("yb_bookmarks_menu_hide_this_menu");
      var sep;

      if (hideThisMenu && hideThisMenu.parentNode == popup) {
         sep = document.getElementById("yb_bookmarks_menu_hide_this_menu_sep");
         popup.removeChild(sep);
         popup.removeChild(hideThisMenu);
       }

       hideThisMenu = document.createElement("menuitem");
       hideThisMenu.setAttribute("observes", "yb-broadcaster-bookmarksmenu-hide-this");
       hideThisMenu.setAttribute("id", "yb_bookmarks_menu_hide_this_menu");
       sep = document.createElement("menuseparator");
       sep.setAttribute("id", "yb_bookmarks_menu_hide_this_menu_sep");

       popup.appendChild(sep);
       popup.appendChild(hideThisMenu);

   },

   bookmarkThisTab: function() {
    var tab = getBrowser().mContextTab;
    if (tab.localName != "tab")
        tab = getBrowser().mCurrentTab;
    yAddBookMark.addBookmarkForTabBrowser(tab.linkedBrowser);
   },

   /* necc because we don't have a way of getting a resource for multiple tags yet */
/*   _refreshTagsToolbarMenuDatasource: function() {
     try {
      var container = Components.classes["@mozilla.org/rdf/container;1"].
                       createInstance(Components.interfaces.nsIRDFContainer);
      container.Init(this._tagsToolbarMenuDatasource, grsrcTagsToolbarMenu);

      // empty elements
      var containerEnum = container.GetElements();
      while (containerEnum.hasMoreElements()) {
        var e = containerEnum.getNext();
        container.RemoveElement(e, true);
      }

      //add tags
      var tags = ybBags.getTagsToolbarBag().tags;
      for(var i=0; i<tags.length; i++) {
        var rsrcName = this.gBookmarks.getTagResourceName(tags[i]);
        if (rsrcName) {
          var rsrc = gYBRdfService.GetResource(rsrcName);
          rsrc.QueryInterface(Components.interfaces.nsIRDFNode);
          container.AppendElement(rsrc);
        }
      }

      var menu = document.getElementById("ybookmarks_tags_toolbar");
      menu.builder.rebuild();

    } catch (e) {
      alert(e);
    }
   },
  */
   _exciseMenuDestructive: function(parent, start, end) {
     var start_i = -1;
     for(var i=0; i < parent.childNodes.length; i++) {
         if (parent.childNodes[i] == start) {
           start_i = i;
           break;
         }
     }
     if (start_i >= 0) {
       var child = parent.childNodes[start_i+1]; // for some reason, a for loop doesn't work... early binding?
       while (child != end) {
          parent.removeChild (child);
          child = parent.childNodes[start_i+1];
       }

     }

   },

   addTagsToolbarToMenu: function(event) {

     try {
        //Hide switchButton on pending mode switch.
       if(ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_CLASSIC)  {
          var pref = Components.classes["@mozilla.org/preferences-service;1"].
                 getService(Components.interfaces.nsIPrefBranch);
          var modeChange = pref.getCharPref("[e-mail]");
          if(modeChange == YB_EXTENSION_MODE_STANDARD) {
              var switchButton = document.getElementById("ybookmarks_switch_to_std_mode");
              switchButton.hidden = true;
          }
       }
       if (event.target.id != "ybookmarks_menu_popup" || ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_CLASSIC) {
          return;
       }
       var myTagsMenu = document.getElementById( "ybookmarks_tags_menu" );
       if ( myTagsMenu ) {
        /* var threshold = Y_DEFAULT_BOOKMARKS_THRESHOLD;
         try {
           threshold = this.prefs.getIntPref( "[e-mail]" );
         } catch ( e ) {
         }

         if ( this._cachedTotalBookmarks > threshold || (this._cachedTotalBookmarks = this.gBookmarks.getTotalBookmarks()) > threshold ) {
           myTagsMenu.hidden = true;
         } else {
           myTagsMenu.hidden = false;
         }*/

         try {
           myTagsMenu.hidden = this.prefs.getBoolPref("[e-mail]");
         } catch (e) {
           yDebug.print("error with gettting preference: [e-mail]: " + e);
         }
       }

       /*var container = Components.classes["@mozilla.org/rdf/container;1"].
                       createInstance(Components.interfaces.nsIRDFContainer);
       container.Init(this._tagsToolbarMenuDatasource, grsrcTagsToolbarMenu);
       */
       var popup = event.target;
       var start = document.getElementById("ybookmarks_tags_toolbar_start");
       var stop = document.getElementById("ybookmarks_tags_toolbar_stop");
       this._exciseMenuDestructive(popup, start, stop);

       var tags = ybBags.getFavoriteTags();

       for (var i=0; i < tags.length; i++) {
        var tagArg =  {name: tags[i],
                       url: "",
                       icon: "",
                       type: YB_TYPE_TAG,
                       order: ybBags.getFavoriteTagOrder(tags[i]),
                       menubar: true,
                       favoriteTag: true};
        var menuItem = ybBookmarksMenu.createMenuItem(tagArg);
        popup.insertBefore(menuItem, stop);

       }
/*
       var XULNS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
       var menu, menupopup, tag, id;
       for(var i=0; i<tags.length; i++) {

         var favTag = tags[i];
         id = "ybbookmarks_tags_toolbar_"+i;

         var menu = document.createElementNS(XULNS, "menu");
         menu.setAttribute("container", true);
         menu.setAttribute("id", id);
         menu.setAttribute("label", favTag);
        // menu.setAttribute("order", order);
         menu.setAttribute("class", "menu-iconic yb-tag-item");
         menu.setAttribute("container", "true");
         menu.setAttribute("onpopupshowing", "ybookmarksMain._onFavoriteTagShowing(event);")

         menu.setAttribute("datasources", "rdf:null");
         menu.setAttribute("template", "ybookmarks_tags_toolbar_template");

         menupopup = document.createElementNS(XULNS, "menupopup");
         menupopup.setAttribute("contextmenu", "yb-bookmarks-context-menu");
         menu.appendChild(menupopup);
         popup.insertBefore(menu, stop);

         var favTagResource = ybBags.isFavoriteTag(favTag);
         if (favTagResource) {
           favTagResource.QueryInterface(Components.interfaces.nsIRDFResource);
           menu.setAttribute("ref", favTagResource.Value);
           menu.database.AddDataSource(this.gBookmarks.getDataSource());
         //  menu.builder.rebuild();
         }

       }
*/
      } catch (e) {
      yDebug.print("addTagsToolbarToMenu(): " + e, YB_LOG_MESSAGE);
     }
   },

   onBundlesPopupShowing: function (event) {
     var popup = event.target;
     var end = document.getElementById("ybookmarks_bundles_menubar_popup_end");

     while(popup.childNodes[0] != end) {
       popup.removeChild(popup.childNodes[0]);
     }

     var bundles = this.gBookmarks.getBundles({});
     for (var i=0; i < bundles.length; i++) {
       var b = bundles[i];
       var bArg = { name: b.name,
                    type: YB_TYPE_BUNDLE};
       var menuItem = ybBookmarksMenu.createMenuItem(bArg);

       popup.insertBefore(menuItem, end);
     }

   },

   _getIntersectingBookmarks : function(favtags) {
     var intersected = [];

     var conUtils = Components.classes["@mozilla.org/rdf/container-utils;1"].
                       getService(Components.interfaces.nsIRDFContainerUtils);

     var bm = {};
     var numTags = 0;  // number of valid tags (e.g. no "")
     // combine all the resources of each favorite tag
     for(var j=0; j < favtags.length; j++) {
       var ft = favtags[j];
       if (ft == "") { continue; }
       numTags++;
       var ftRsrcName = this.gBookmarks.getTagResourceName(ft); // check if this tag is used
       if (ftRsrcName) {
         var ftRsrc = gYBRdfService.GetResource(ftRsrcName);
         // take all the bookmarks of this tag and append it to the root
         var con = conUtils.MakeSeq(this.gBookmarks.getDataSource(), ftRsrc);
         var enu = con.GetElements();
         while (enu.hasMoreElements()) {
           var r = enu.getNext();
           r.QueryInterface(Components.interfaces.nsIRDFResource);
           var key = r.Value;
           if (bm[key] == undefined) {
             bm[key] = {count: 1,
                         rsrc: r};
           } else {
             bm[key].count++;
           }
         }
       }
     }

     for each (b in bm) {
       if (b.count == numTags) {
         intersected.push(b.rsrc);
       }
     }
     return intersected;
   },

   /* kludge: as it seems, RSS feeds tend to be in reverse-chrono order.  The problem
      is that the datasource adds these livemakrs in order, so the newest has the oldest adddate.
      So: ascending add date -> descending actual date */
   reverseLivemarkMenu: function(menu) {
     if (!menu.getAttribute("reversed")) {
       var copy = new Array(menu.childNodes.length);
       var i = 0;
       while (menu.childNodes.length) {
         copy[i] = menu.removeChild(menu.firstChild);
         i++;
       }
       for (i=copy.length-1; i >=0 ; i--) {
         menu.appendChild(copy[i]);
       }
       menu.setAttribute("reversed", true);
     }
   },

   _getLivemarkAddDate: function (aLivemark) {
      var bm = this.gBookmarks.getBookmark(aLivemark.getAttribute("url"));
      bm.QueryInterface(Components.interfaces.nsIYBookmark)
      return bm.added_date;
   },

   sortLivemarkMenu: function(menu, aOrder) {
     //if (!menu.getAttribute("reversed")) {
       try {
       var copy = [];
       var i = 0;
       while (menu.childNodes.length) {
         var item = menu.removeChild(menu.firstChild);
         if (item.getAttribute("url")) {
           copy.push(item);
         }
       }
       var func = null;
       // remember that livemark items are processed in order of the xml file
       // so most recent items actually have an earlier add date
       if (aOrder == FAVTAGS_ORDER_CHRONO) {
         func = function(a, b) { return ybookmarksMain._getLivemarkAddDate(b) - ybookmarksMain._getLivemarkAddDate(a) };
       } else if (aOrder == FAVTAGS_ORDER_CHRONO_REVERSE) {
         func = function(a, b) { return ybookmarksMain._getLivemarkAddDate(a) - ybookmarksMain._getLivemarkAddDate(b) };
       } else if (aOrder == FAVTAGS_ORDER_ALPHANUM) {
          func = function(a, b) { return a.getAttribute("label").localeCompare(b.getAttribute("label")); };
       } else if (aOrder == FAVTAGS_ORDER_ALPHANUM_REVERSE) {
          func = function(a, b) { return b.getAttribute("label").localeCompare(a.getAttribute("label")); };
       } else if (aOrder == FAVTAGS_ORDER_USER) {
          func = null;
       }

       if (func) {
         copy.sort(func);
       }

       for (var i=0; i < copy.length ; i++) {
         menu.appendChild(copy[i]);
       }
       //menu.setAttribute("reversed", true);
     //}
   } catch (e) {yDebug.print(e);}
   },

  /* _onFavoriteTagShowing : function(event) {
     try {

       var popup = event.target;
       var menu;
        if (popup.parentNode.id.indexOf("ybbookmarks_tags_toolbar_") != -1) {
           menu = popup.parentNode;
       } else if (popup.parentNode.getAttribute("livemark")) {
          menu = popup.parentNode.parentNode.parentNode;
       }
       var favTag = menu.getAttribute("label");
       var order = ybBags.getFavoriteTagOrder(favTag);
        var sortResource, sortDirection;
        if (order == FAVTAGS_ORDER_CHRONO) {
          sortResource = "http://home.netscape.com/NC-rdf#BookmarkAddDate";
          sortDirection = "ascending";
        }  else if (order == FAVTAGS_ORDER_CHRONO_REVERSE) {
          sortResource = "http://home.netscape.com/NC-rdf#BookmarkAddDate";
          sortDirection = "descending";
        }  else if (order == FAVTAGS_ORDER_ALPHANUM) {
          sortResource = "http://home.netscape.com/NC-rdf#Name";
          sortDirection = "ascending";
        }  else if (order == FAVTAGS_ORDER_ALPHANUM_REVERSE) {
          sortResource = "http://home.netscape.com/NC-rdf#Name";
          sortDirection = "descending";
        } else if (order == FAVTAGS_ORDER_USER) {
          sortResource = null;
          sortDirection = null;
        }

       if (popup.parentNode.id.indexOf("ybbookmarks_tags_toolbar_") != -1) {

         while(popup.childNodes.length) {
           popup.removeChild(popup.lastChild);
         }

         if (sortResource) {
           menu.setAttribute("sortResource", sortResource);
           menu.setAttribute("sortDirection", sortDirection);
         }
         menu.builder.rebuild();

         if (popup.childNodes.length) {
           YBtabsOpener.addMenuItem(popup);
         }
         else {
           ybookmark_Utils.addEmptyMenuItem(popup);
         }

         ybookmarks_Main.addPopularPageMenuItem(event);

       } else if (popup.parentNode.getAttribute("livemark")) {
          //this.sortLivemarkMenu(popup, FAVTAGS_ORDER_CHRONO_REVERSE);

          if (popup.childNodes.length) {
             YBtabsOpener.addMenuItem(popup);
           }
       }
     } catch (e) {
       yDebug.print("_onFavoriteTagShowing():" + e);
     }
   },
*/

   loadRelevantPage : function(event, aStr, aMouseClick){
      var del = Components.classes[Y_kDelContractID]
                 .getService( Components.interfaces.nsISocialStore );

      var user = del.getUserName();
      var url = null;
      switch(aStr){
      case "login":
       if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl("logout");
         break;
      case "logout":
         url = deliciousService.getUrl("logout");
         break;
      case "moreabout":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getMoreAboutUrl(content.location);
         break;
      case "your":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl(user);
         break;
      case "network":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl("network/" + user);
         break;
      case "tags":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl("tags/" + user);
         break;
      case "subscriptions":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl("subscriptions/" + user);
         break;
      case "inbox":
      case "for":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl("for/" + user);
         break;
      case "settings":
         if(!user)
            url = del.login_url;
         else
            url = deliciousService.getUrl("settings/" +
                user + "/profile");
         break;
      case "homepage":
         url = deliciousService.getUrl("");
         break;
      case "popular":
         url = deliciousService.getUrl("popular/");
         break;
      case "recent":
         url = deliciousService.getUrl("recent/");
         break;
      case "about":
         url = deliciousService.getUrl("about");
         break;
      case "help":
         url = deliciousService.getUrl("help/");
         break;
      case "tour":
         var strings = document.getElementById("ybookmarks-strings");
         url = deliciousService.getQuickTourUrl();
         break;
      case "bundles":
         url = deliciousService.getBundleUrl();
         break;
      case "editbundle":
        url = deliciousService.getEditBundleUrl(event.bundle);
        break;
      default:
         url = deliciousService.getUrl();
         break;
      }

      if (url) {
         this.UIloadPage(event, url, aMouseClick);
      }
   },

   UIloadPage : function(event, aUrl, aMouseClick){

     var browser = document.getElementById("content");
     if(aMouseClick){
       if(event.button == 1){
         if(event.target.localName == "menuitem") {
           var menu = event.target.parentNode;
           while( menu.localName == "menu" || menu.localName == "menupopup" ) {
             if( menu.localName == "menupopup" ) {
               menu.hidePopup();
             }
             menu = menu.parentNode;
           }
         }
         var tab = browser.addTab(aUrl);
         browser.selectedTab = tab;
       }
     }
      else{
        if(!event){
          browser.loadURI(aUrl);

        return;
        }

        var shift = event.shiftKey;
        var ctrl =  event.ctrlKey;
        if (ctrl) {
          var tab = browser.addTab(aUrl);
          browser.selectedTab = tab;
        }
        else if(shift){
          openDialog("chrome://browser/content/browser.xul", "_blank", "chrome,all,dialog=no", aUrl);
        }
        else
          browser.loadURI(aUrl);
      }

   return;
   },
    /* check for validity of user's cookie once on startup */
    checkUserLoggedInState:function(){
        var del = Components.classes[Y_kDelContractID].getService( Components.interfaces.nsISocialStore );
        var cb = {
        onload: function (event) {
         yDebug.print("ybookmarksOverlay.js::checkUserLoggedInState()=>Onload", YB_LOG_MESSAGE);
        },
        onerror: function (event) {
            if(event.target.status == 403 || event.target.status == 401) {
                //do silent logout
                yDebug.print("ybookmarksOverlay.js::checkUserLoggedInState()=> Received 401 or 403 response from the server", YB_LOG_MESSAGE);
                 Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService)
           .notifyObservers(null, "ybookmark.userChanged", "triggerSilentLogout");
            }
            yDebug.print("ybookmarksOverlay.js::checkUserLoggedInState()=>Error", YB_LOG_MESSAGE);
        }
        }
        del.lastUpdate(cb);
    },

   isEngineInstalled : function(){
      var installed = false;
      var newVersionNum = this.strings.getString("extensions.ybookmarks.versionNum");
      try {
          var oldVersionNum = this.prefs.getCharPref("[e-mail]");
      }catch (e){
          yDebug.print("ybookmarksOverlay.js::ybookmarksMain::isEngineInstalled()=>Engine not installed",
              YB_LOG_MESSAGE);
      }
      if(newVersionNum == oldVersionNum){
          installed = true;
          yDebug.print("ybookmarksOverlay.js::ybookmarksMain::isEngineInstalled()=>Engine installed",
              YB_LOG_MESSAGE);

         }
         return installed;
   },


   installEngine : function() {
     yDebug.print("ybookmarksOverlay.js::ybookmarksMain::installEngine()=> Installing Engine...",YB_LOG_MESSAGE);
     // Create delicious XT session cookie
     /*
     ybookmarksUtils.setCookie(DEL_COOKIE_NAME, DEL_COOKIE_URL, DEL_COOKIE_DOMAIN,
         DEL_COOKIE_DATA, DEL_COOKIE_EXPIERE_AFTER_DAYS);         */
/*
         var tourURL = deliciousService.getTourUrl();
          yDebug.print("ybookmarksOverlay.js::ybookmarksMain::installEngine()=> Redirecting to: "
            + tourURL, YB_LOG_MESSAGE);
        setTimeout(
            function(aUrl){
                try {
                  var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
                                     .getService(Components.interfaces.nsIWindowMediator);
                  var browserEnumerator = wm.getEnumerator("navigator:browser");

                  // Check each browser instance for our URL
                  var found = false;
                  while (!found && browserEnumerator.hasMoreElements()) {
                    var browserInstance = browserEnumerator.getNext().getBrowser();

                    // Check each tab of this browser instance
                    var numTabs = browserInstance.tabContainer.childNodes.length;
                    for(var index=0; index<numTabs; index++) {
                      var currentBrowser = browserInstance.getBrowserAtIndex(index);
                      if (deliciousService.getRegisterSuccessUrl() == currentBrowser.currentURI.spec) {
                        // The URL is already opened. Select this tab.
                        browserInstance.selectedTab = browserInstance.tabContainer.childNodes[index];
                        // Focus *this* browser
                        browserInstance.focus();
                        browserInstance.removeTab(browserInstance.selectedTab);
                        found = true;
                        break;
                      }
                    }
                  }

                  browserInstance.addTab(aUrl);
                } catch(e) {
                    yDebug.print("Except: "+e, YB_LOG_MESSAGE);
                }
                },
            200, tourURL
         );
*/
    /** Disabled for now **
    // Always show tagometer dialog if we upgrade to or install 2.0
    var currentVersionNum = this.strings.getString("extensions.ybookmarks.versionNum");
    var versionChecker = Components.classes["@mozilla.org/xpcom/version-comparator;1"].getService(Components.interfaces.nsIVersionComparator);
    if (versionChecker.compare(currentVersionNum, "2.0.00") >= 0) {
        yDebug.print("ybookmarksOverlay.js::ybookmarksMain::installEngine()=> Invoking Tagometer Dialog", YB_LOG_MESSAGE);
        var button_number = showEnableTagometerDialog();
        if(button_number == 0) { // user selected enable tagometer
            this.prefs.setBoolPref("[e-mail]_tagometer", true);
        }
    }
    */
    this.firstTimeStart();

    //For intro Wizard.
    try {
         if(this.prefs.getBoolPref("[e-mail]")) {
            //return true;
         } else {
            //Wizard not installed
            var rv = new Object();
            rv.aborted = false;
            window.openDialog("chrome://ybookmarks/content/introWiz.xul", "options",
                                "centerscreen,modal", rv);
            //Sets the toolbar icons
            if (rv.aborted) {
               yDisableExtensions.uninstallYBookmarks();
               ybookmarksUtils.restartBrowser();
               return false;
            }

         }
    } catch(e){}
    return true;
   },

   onTagsMenuPopupShowing: function(event) {
     try {
         var popup = event.target;
         while(popup.childNodes.length) {
           popup.removeChild(popup.lastChild);
         }
         var tags = ybookmarksMain.gBookmarks.getTags(null, {});
         tags.sort(function(a,b) { return a.localeCompare(b); });
         for (var i=0; i < tags.length; i++) {
           var tag = tags[i];
           var tagArg = { name: tag,
                          type: YB_TYPE_TAG,
                          menubar: true,
                          order: FAVTAGS_ORDER_ALPHANUM };
           var item = ybBookmarksMenu.createMenuItem(tagArg);
           popup.appendChild(item);
         }
     } catch (e) {
      yDebug.print("onTagsMenuPopupShowing(): " + e);
     }

   },
   /*
   rebuildTagsMenu: function(event) {

     if ( ybookmarksMain.isNewTagAdded && !ybookmarksMain.isChangingDatasource) {

       var target = document.getElementById("ybookmarks_tags_1");
       if ((event && event.target.parentNode.id == "ybookmarks_tags_1") ||
          (!event && target.getAttribute("open") != "true")) {
         yDebug.print("===>Rebuilding My Tags ", YB_LOG_MESSAGE);
         target.builder.rebuild();
         ybookmarksMain.isNewTagAdded = false;
       }
     }
   },*/


   /*
   showTagsToolbarMenu: function(event, menuElement) {

    if (event.target.parentNode.id == "ybookmarks_tags_toolbar") {

       this._refreshTagsToolbarMenuDatasource();

       var menupopup = event.target;
       var item = document.createElement( "menuseparator" );
       item.setAttribute("nontag", "true");
       menupopup.appendChild(item);

       var item = document.createElement("menuitem");
       item.setAttribute("class", YB_MENUITEM_NOICON);
       item.setAttribute("label", this.strings.getString("extensions.ybookmarks.toolbar.editor.label"));
       item.setAttribute("command", "cmd_yb_open_toolbar_editor");
       item.setAttribute("nontag", "true");
       menupopup.appendChild(item);

       var item = document.createElement("menuitem");
       item.setAttribute("class", YB_MENUITEM_NOICON);
       item.setAttribute("label", this.strings.getString("extensions.ybookmarks.toolbar.show.label"));
       //item.setAttribute("oncommand", "try {document.getElementById('ybToolbar').hidden=false;} catch(e) {alert(e);}");
       item.setAttribute("nontag", "true");
       menupopup.appendChild(item);
    }
  },

   hideTagsToolbarMenu : function(event) {

     if (event.target.parentNode.id == "ybookmarks_tags_toolbar") {

       var menupopup = event.target;
       var item = menupopup.lastChild;
       while (item) {
         mitem = item;
         item = item.previousSibling;
         if (mitem.getAttribute("nontag") == "true") {
           menupopup.removeChild(mitem);
         }
       }
     }
   },
   */

   /*
   rebuildBookmarksMenu: function(event, menuElement) {
     if ( ybookmarksMain.isBookmarkChanged ) {
       menuElement.builder.rebuild();
       ybookmarksMain.isBookmarkChanged = false;
     }
   },
   */

   /*
   onMainPopupShowing: function(event) {

     ybookmarks_Main.addEmptyMenuItem( event );
     if ( this.isBookmarkChanged) {
       ybookmarks_Main.addBookmarkItemsToMainMenu();
       this.isBookmarkChanged = false;
     }
   },
   */

   onFrequentMenuPopupShowing: function(event) {
     var total = ybookmarks_Main.addBookmarksToPopup(event.target, 'bookmark-sort-tree-visitcount-col');
/*     if (ybookmarksMain._is_frequent_menu_update_required ) {
       var total = ybookmarks_Main.addBookmarksToPopup(event.target, 'bookmark-sort-tree-visitcount-col');
       ybookmarksMain._is_frequent_menu_update_required = (total  == 0);
     }*/
   },

   /*
   onRecentMenuPopupShowing: function(event) {
     if (ybookmarksMain._is_recent_menu_update_required ) {
       ybookmarks_Main.addBookmarksToPopup(event.target, 'bookmark-sort-tree-visitdate-col');
       ybookmarksMain._is_recent_menu_update_required = false;
     }
   },
   */

   onRecentlySavedMenuPopupShowing: function(event) {
      var total = ybookmarks_Main.addBookmarksToPopup(event.target, 'bookmark-sort-tree-adddate-col');

     /*if (ybookmarksMain._is_recently_saved_menu_update_required ) {
       var total = ybookmarks_Main.addBookmarksToPopup(event.target, 'bookmark-sort-tree-adddate-col');
       ybookmarksMain._is_recently_saved_menu_update_required = ( total == 0 );
     }*/
   },

   /*
   startImport: function (addTagsAsArray, addPopularTags, replaceDuplicates, filePath) {
      ybookmarksUtils.startImport(addTagsAsArray, addPopularTags, replaceDuplicates, filePath);
   },
   */

   openImportProgress: function (data) {
         window.openDialog("chrome://ybookmarks/content/importProgress.xul", "yb-import-progress", "centerscreen", data);
   },

   _importBookmarksObserver: {

     observe: function(subject, topic, data) {

       try {
         if (topic == "ybookmark.importBookmarks") {
           yDebug.print("ybookmarksOverlay.js::_importBookmarksObserver()=> Inside import observer....",
                   YB_LOG_MESSAGE);

           var pgrText = document.getElementById("ybookmark-import-progresstext" );
           var pgrMeter = document.getElementById("ybookmark-import-progressmeter" );
           var pgrStatus = document.getElementById("ybookmark-import-progress-statusbarpanel" );
           var strings = document.getElementById( "ybookmarks-strings" );

           subject.QueryInterface(Components.interfaces.nsISupportsString);

           /* display the import progress on statusbar */
           if (subject.data == "startImport") {
             pgrStatus.collapsed = false;
             pgrText.collapsed = false;
             pgrMeter.collapsed = false;
             pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.importing" );
           }
           else if (subject.data == "importProgress") {

             switch (data) {

               case "complete":
                 pgrMeter.collapsed = true;
                 pgrStatus.collapsed = false;
     pgrText.collapsed = false;
                 pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.importdone" );
                 setTimeout(function(){
                     //only hide this if "importing successfully" text is showing
                     if (pgrText.value == strings.getString( "extensions.ybookmarks.statusbar.importdone" )) {
                       pgrStatus.collapsed = true;
                       pgrText.collapsed = true;
                       pgrMeter.collapsed = true;
                     }
                   }, 30000);
               break;
               case "importing":
                 pgrStatus.collapsed = false;
                 pgrText.collapsed = false;
                 pgrMeter.collapsed = false;
                 pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.importing" )
               break;
               case "failed":
                 pgrMeter.collapsed = true;
                 pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.importfailed" );
               break;
             }
           }
           else if (subject.data == "importError") {
             pgrMeter.collapsed = true;
             pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.importfailed" );
           }


           /* this guarantees that having multiple windows won't cause problems. */
           var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].
                 getService(Components.interfaces.nsIWindowMediator);
           var recentWindow = wm.getMostRecentWindow("navigator:browser");
           if (recentWindow != window) {
             return;
           }
           /*
           var winEnumerator = wm.getEnumerator("navigator:browser");
           var isFirstWindow = (winEnumerator.getNext() == window);
           if (!isFirstWindow) {
             return;
           }
           */
           if (subject.data == "startImport") {
                if(!ybookmarksUtils.isRecentWindow()) { //To make sure that import is initiated by recent window alone
                    return;
                }
             try {
               var dataString = new String(data);
               var args = YBJSON.parse(dataString);

               var addTags = args.addTags;
               var addPopularTags = args.addPopularTags;
               var replaceDuplicates = args.replaceDuplicates;
               var email = args.email;
               var priv = args.priv;

               if (args.filePath != null) { // check for null, not "".  "" means Firefox's bookmarks.html
                 setTimeout ( function() { ybookmarksUtils.startImport(addTags, addPopularTags, replaceDuplicates, args.filePath, email, priv); }, 0);
               } else if (args.bookmarksString){
                 setTimeout ( function() { ybookmarksUtils.startImportWithBookmarksString(addTags, addPopularTags, replaceDuplicates, args.bookmarksString, email, priv); }, 0);
               }
             } catch (e) {
              yDebug.print(e, YB_LOG_MESSAGE);
             }

           } else if (subject.data == "importProgress") {
             //complete", "importing" or "failed
             if (data == "complete" || data == "failed") {
               if (data == "complete" && ybookmarksMain.isEngineInstalled()) {
                 ybookmarksMain.syncservice.sync(false);
               }

               if (ybookmarksMain.isBookmarkImportPolling()) {
                 ybookmarksMain.openImportProgress(data);
                 ybookmarksMain.setBookmarkImportPolling(false);
               }
             } else {
               setTimeout(function() {
                    var ssr =
                        Components.classes["@yahoo.com/socialstore/delicious;1"].
                           getService(Components.interfaces.nsISocialStore);
                    ssr.getImportStatus(ybookmarksUtils.importStatusCallback); },
                    Y_BOOKMARKS_IMPORT_POLLING_PERIOD);
              }
            } else if (subject.data == "importError") {
              ybookmarksMain.openImportProgress("failed");
              ybookmarksMain.setBookmarkImportPolling(false);
            }
          }

       } catch (e) {
         yDebug.print("importBookmarksObserver: " + e, YB_LOG_MESSAGE);
       }
     }
   },

   importBookmarks: function() {

     if(!YBidManager.isUserLoggedIn()) {
       YBidManager.promptUserLogin();
       try {
          if (window.ybLoginWindowFlag == "display") {
             YBPopupWindow.showLoginWindow();
          }
       } catch(e) {
            // do nothing
       }
       return;
     }

     var callback = {
       _ybookmarksMain: null,

       onload: function(result) {
          var propertyBag = result.queryElementAt(0, Components.interfaces.nsIPropertyBag);
          var status = propertyBag.getProperty("status");
          //"complete", "importing" or "failed"
          if (status == "importing") {
              ybookmarksMain.openImportProgress("importing");
              if (!this._ybookmarksMain.isBookmarkImportPolling()) {
                this._ybookmarksMain.setBookmarkImportPolling(true);
                setTimeout(function() {
                            var ssr = Components.classes["@yahoo.com/socialstore/delicious;1"].
                              getService(Components.interfaces.nsISocialStore);
                            ssr.getImportStatus(ybookmarksUtils.importStatusCallback); },
                          Y_BOOKMARKS_IMPORT_POLLING_PERIOD);
              }

          } else {
            this._ybookmarksMain.setBookmarkImportPolling(false);
            window.openDialog("chrome://ybookmarks/content/importBookmarks.xul", "yb-import-bookmarks",
                                "chrome,centerscreen");
          }
       },
       onerror: function(event) {
       }
     };

     var ssr = Components.classes["@yahoo.com/socialstore/delicious;1"].
             getService(Components.interfaces.nsISocialStore);
     callback._ybookmarksMain = this;
     ssr.getImportStatus(callback);
   },

   forceRefresh: function() {
       //TODO: Implement better solution to workaround sync failure.
       var del = Components.classes[Y_kDelContractID].getService( Components.interfaces.nsISocialStore );
       var cb = {
            onload: function (event) {
                 yDebug.print("ybookmarksOverlay.js::forceRefresh()=>Onload");
                 ybookmarksMain.gBookmarks.deleteAllBookmarks(false);
                 ybookmarksMain.gBookmarks.clearBundles();
                 //TODO: Do we need to clean fav tags?
                 ybookmarksMain.gBookmarks.cleanOutFavoriteTags();
                 ybToolbar.refreshCurrentView();
                 ybookmarksMain.gBookmarks.setLastUpdateTime("");
                 ybookmarksMain.syncservice.sync(false);
            },
            onerror: function (event) {
                yDebug.print("ybookmarksOverlay.js::forceRefresh()=>OnError", YB_LOG_MESSAGE);
                var obsService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
                obsService.notifyObservers(null, "ybookmark.syncBegin", "no-update");
                obsService.notifyObservers(null, "ybookmark.syncDone", "sync-aborted");
            }
       }
       del.lastUpdate(cb);
   },

   /**
    * Set the UI based on the login state
    */
   setLoginState : function() {

      var socialStore = Components.classes[Y_kDelContractID]
                 .getService( Components.interfaces.nsISocialStore );

      var username = socialStore.getUserName();
      if (username) {
        YBidManager.setLastUsername(username);
        this.setLoggedInState (username)
      }
      else {
        this.setLoggedOutState();
      }
   },

   setLoggedInState : function(username) {

     var loggedInElement =  document.getElementById("ybookmarks_loggedin_menu");
     var loginElement =  document.getElementById("ybookmarks_login_menuitem");
     var pgrStatus = document.getElementById("ybookmark-import-progress-statusbarpanel" );

     if (loggedInElement) {
       if (this.strings) {
         loggedInElement.setAttribute("label", this.strings.getFormattedString("ybookmarks.loggedInAs", [username]));
       }
       loggedInElement.hidden = false;
     }
     if (loginElement) {
       loginElement.hidden = true;
     }
     if (pgrStatus) {
       pgrStatus.hidden = false;
     }
   },

   setLoggedOutState : function() {
     var loggedInElement =  document.getElementById("ybookmarks_loggedin_menu");
     var loginElement =  document.getElementById("ybookmarks_login_menuitem");
     var pgrStatus = document.getElementById("ybookmark-import-progress-statusbarpanel" );

     loggedInElement.hidden = true;
     loginElement.hidden = false;
     if (pgrStatus) {
       pgrStatus.hidden = true;
     }
   },

   delMenuShowing: function( menu ) {
      var i, val;
      var debugMode = yDebug.on( true );
      for(i = 0; i < menu.childNodes.length; ++i ) {
         val = ( menu.childNodes[ i ] ).getAttribute( "yb_debugModeOnly" );
         if( val && ( val == "true" ) ) {
            ( menu.childNodes[ i ] ).hidden = !debugMode;
         }
      }
   },

   _addBookmarkObserver: {
       observe: function(subject, topic, data) {
         if (topic == "ybookmark.addBookmark") {
             if(data) {
                setTimeout( function() {yAddBookMark.open(data);} , 650);
             } else {
                setTimeout( function() {yAddBookMark.open( "", "", null, null, null, null, true );} , 650);
             }
         }
       }
    },

    _disableExtensionObserver: {
       observe: function(subject, topic, data) {
         if (topic == "ybookmark.disableExtension") {
            var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].
                  getService(Components.interfaces.nsIWindowMediator);
            var recentWindow = wm.getMostRecentWindow("navigator:browser");


            if (recentWindow == window) {
              if (data == "cancel") {
               // cmyang: 2006-10-26 don't know why, but the timeout is necc,
               // otherwise Fx 1.5 o Mac crashes on shutdown
              yDebug.print("Disabling bookmonkey");
              setTimeout(
                 function() {yDisableExtensions.disableYBookmarks();}, 0);
              } else if (data == "accept") {
                yDebug.print("Disabling non-compatible extensions");
                setTimeout ( function() {ybookmarksUtils.restartBrowser(); }, 0);
              }
             }
          }
       }
    },

   _errorObserver: {
     observe: function(subject, topic, data) {

       var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].
                        getService(Components.interfaces.nsIWindowMediator);
       var recentWindow = wm.getMostRecentWindow("navigator:browser");
       if (recentWindow == window) {
        if (topic == "ybookmark.serverError") {
           var dataObject = YBJSON.parse(data);
           window.openDialog(
             "chrome://ybookmarks/content/serverError.xul",
             "server-error-dialog",
             "chrome,dialog,centerscreen,modal,resizable=no",
             dataObject);
         }
       }

     }
   },

   // initiates an import based on import cookie
   _importBookmarks : function(importCookie){

    try {
    var decodedCookieData = decodeURIComponent(importCookie.value);
    yDebug.print("Import Cookie : " + decodedCookieData, YB_LOG_MESSAGE);
    var cookieData =  decodedCookieData.split("|");
    var map = new Object();
    for(i=0;i<cookieData.length;i++){
        var pair = cookieData[i].split("=");
        map[pair[0]]=pair[1];
    }
    var tagsArray = map["usertags"] ? map["usertags"].split("+") : [];
    // TBD: handle easy vs custom and test import
    var args = YBJSON.stringify({ addTags: ((map.add_tags == 1) ? tagsArray : []),
                                addPopularTags: (map.pop_tags ==1),
                                replaceDuplicates: (map.duplicate==0),
                                filePath: "", email:(map.email), priv:(map.priv)});

      var xpcArgs = Components.classes["@mozilla.org/supports-string;1"].
                  createInstance(Components.interfaces.nsISupportsString);
      var xpcSubject = Components.classes["@mozilla.org/supports-string;1"].
                      createInstance(Components.interfaces.nsISupportsString);
      xpcSubject.data = "startImport";
      xpcArgs.data = args;
     var os = Components.classes["@mozilla.org/observer-service;1"]
                                   .getService(Components.interfaces.nsIObserverService);
       os.notifyObservers(xpcSubject, "ybookmark.importBookmarks", xpcArgs);
    } catch (e) {
        yDebug.print("ybookmarksOverlay.js::_importBookmarks()=> Exception: "+e, YB_LOG_MESSAGE);
    }
   },
   _cookieObserver: {
     observe: function(subject, topic, data) {
         if(!ybookmarksUtils.isRecentWindow()) {
             yDebug.print("ybookmarksOverlay.js::_cookieObserver()=> Returning quietly as this is not recentWindow. ");
             return;
         }
        if (data == "added" || data == "changed") {
          try {
            var cookie = subject.QueryInterface ( Components.interfaces.nsICookie );
            var prefDomain = ybookmarksUtils._DOTCOMHOST;
            yDebug.print("ybookmarksOverlay.js::_cookieObserver()=> cookie name = " +cookie.name+" cookie host = "+cookie.host+" pref domain = "+prefDomain);
            // $$$ temporary code (adding "." for testing
            if (cookie.host == prefDomain && cookie.name == DEL_COOKIE_EXT_IMPORT) {
                yDebug.print("ybookmarksOverlay.js::_cookieObserver=>Import Cookie Added or Modified",
                    YB_LOG_MESSAGE);
                   if (YBidManager.isUserLoggedIn()){
                       //Start import after a import status poll check.
                       setTimeout( function() {
                           try {
                               ybookmarksMain._startImportAfterPolling(cookie);
                           } catch(e) {
                               yDebug.print("exception on ybookmarksOverlay.js::_cookieObserver=>_startImportAfterPolling", YB_LOG_MESSAGE);
                           }
                       },
                       0);
                    //ybookmarksMain._importBookmarks(cookie);
                }
            }
            //This is safe, if user sign-in in any, allow sync
            if ( (cookie.host == prefDomain  || cookie.host == ybookmarksUtils._DOTUSHOST) && cookie.name == "_user") {
                yDebug.print("ybookmarksOverlay.js::_cookieObserver()=> _user cookie added",YB_LOG_MESSAGE);
                // If user cookie is added and engine is installed allow sync
                if (ybookmarksMain.isEngineInstalled()) {
                    yDebug.print("ybookmarksOverlay.js::_cookieObserver()=> allowing sync...",YB_LOG_MESSAGE);
                    var ss = Components.classes["@mozilla.org/ybookmarks-sync-service;1"]
                        .getService(Components.interfaces.nsIYBookmarkSyncService);
                    ss.allowSync();
                }
             }
          } catch ( e ) {
            yDebug.print("ybookmarksOverlay.js::_cookieObserver()=>Exception: " + e,YB_LOG_MESSAGE);
          }
        }
      }
    },

    /**
     * Function opens new dialog for jump to tags
     */
    jumpToTag: function() {
        if(YBidManager.isUserLoggedIn() && ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_STANDARD) {
            var win = window.openDialog( "chrome://ybookmarks/content/ybJump.xul",
                   "",
                   "chrome,centerscreen,modal,dialog=no,resizable=no");
        }
    },

    /**
     * Function opens new dialog showing delicious options
     */
     showDeliciousOptions: function () {
        if (!gPrefsWindow || gPrefsWindow.closed) {
            gPrefsWindow = window.openDialog("chrome://ybookmarks/content/options.xul", "Delicious Options","chrome,titlebar,toolbar,centerscreen,dialog=no");
            gPrefsWindow.focus();
        } else {
            gPrefsWindow.focus();
        }
     }
};

function yb_restoreBookmarks(backup) {
    var root = RDF.GetResource("NC:BookmarksRoot");
    BMDS.beginUpdateBatch();
    if (RDFCU.IsSeq(BMDS, root)) {
        var seq = RDFCU.MakeSeq(BMDS, root);
        var seqElements = seq.GetElements();
        /* remove all children of this folder. */
        while (seqElements.hasMoreElements()) {
            var resource = seqElements.getNext();
            resource.QueryInterface(Components.interfaces.nsIRDFResource);
            var selection = BookmarksUtils.getSelectionFromResource(resource, root);
            if (!selection.containsPTF) {
                BookmarksController.doCommand("cmd_delete", selection);
            }
        }
    }
    BMDS.endUpdateBatch();
    var sidebar = document.getElementById("sidebar-box");
    // close sidebar.
    if (!sidebar.hidden) {
        toggleSidebar('viewYBookmarksSidebar', false);
    }
    var ds = Components.classes["@mozilla.org/file/directory_service;1"].
        createInstance(Components.interfaces.nsIProperties);
    var extraFile = ds.get("ProfD", Components.interfaces.nsIFile);
    // delete extra.rdf
    extraFile.append("extra.rdf");
    if (extraFile.exists()) {
        extraFile.remove(false);
    }

    //in case the file is not deleted
    var localStoreService = Components.classes["@mozilla.org/ybookmarks-store-service;1"].
            getService(Components.interfaces.nsIYBookmarksStoreService);
    localStoreService.setLastUpdateTime("-1");

      /* import the backup file. */
      /* import bookmarks from backup.  */
      RDFC.Init(BMDS, root);

      var countBefore =
        parseInt(BookmarksUtils.getProperty(root, gRDF_NS + "nextVal"));
      var args = [{ property: gNC_NS + "URL", literal: backup.path}];
      var is18branch = false;

      BookmarksCommand.doBookmarksCommand(root, gNC_NS_CMD + "import", args);

      var countAfter = parseInt(BookmarksUtils.getProperty(root, gRDF_NS + "nextVal"));

      try {
         if (gBkmkTxnSvc) {
            is18branch = true;
         }
      } catch (e) {}

      if (is18branch) {
         /* 1.8 branch. */
         if (countAfter - countBefore > 1) {
            gBkmkTxnSvc.startBatch();
         }

         for (var i = countBefore; i < countAfter; i++) {
            var nChildArc = RDFCU.IndexToOrdinalResource(i);
            var rChild = BMDS.GetTarget(root, nChildArc, true);

            gBkmkTxnSvc.createAndCommitTxn(
               gBkmkTxnSvc.IMPORT, "IMPORT", rChild, i, root, 0, null);
         }

         if (countAfter - countBefore > 1) {
            gBkmkTxnSvc.endBatch();
         }
      } else {
         /* 1.7 branch. */
         var transaction = new BookmarkImportTransaction("import");

         for (var i = countBefore; i < countAfter; i++) {
            var nChildArc = RDFCU.IndexToOrdinalResource(i);
            var rChild = BMDS.GetTarget(root, nChildArc, true);

            transaction.item.push(rChild);
            transaction.parent.push(root);
            transaction.index.push(i);
         }

         BMSVC.transactionManager.doTransaction(transaction);
      }
      var currentToolbarFolder = BMSVC.getBookmarksToolbarFolder();
      var currentTFSelection =
         BookmarksUtils.getSelectionFromResource(currentToolbarFolder, root);
      var namePredicate = RDF.GetResource(gNC_NS + "Name");
      var toolbarName;
      /* rename the current folder. */
      BMDS.Assert(
         currentToolbarFolder, namePredicate, RDF.GetLiteral("temp"), true);
      /* get the folder name from the backup. */
      var backupAsString = ybookmarksUtils.fileContentsAsString(backup.path);
      var reMatch = Y_TOOLBAR_FOLDER_RE.exec(backupAsString);

      if (reMatch && reMatch[1]) {
         toolbarName = reMatch[1];
      }

      var toolbarNameLiteral = RDF.GetLiteral(toolbarName);
      /* and point the toolbar folder in the right direction. */
      var newToolbarFolder =
         BMDS.GetSource(namePredicate, toolbarNameLiteral, true);
      var newTFSelection =
         BookmarksUtils.getSelectionFromResource(newToolbarFolder, root);
      BookmarksController.doCommand(
         "cmd_bm_setpersonaltoolbarfolder", newTFSelection);
      /* finally, delete the original toolbar folder. */
      BookmarksController.doCommand("cmd_delete", currentTFSelection);
      BookmarksUtils.flushDataSource();
}

function yb_restoreBookmarksToPlaces(backup) {
    try {
        yDebug.print("ybookmarksOverlay.js::yb_restoreBookmarksToPlaces:: restore bookmarks started", YB_LOG_MESSAGE);

        try {
              var historyService = Components.classes["@mozilla.org/browser/nav-history-service;1"]
                                   .getService(Components.interfaces.nsINavHistoryService);
            var options = historyService.getNewQueryOptions();
            var query = historyService.getNewQuery();

            var bookmarksService = Components.classes["@mozilla.org/browser/nav-bookmarks-service;1"]
                                             .getService(Components.interfaces.nsINavBookmarksService);

            //comment out the next line for now; the bug hasn't been fixed; final version should include the next line
            //options.setGroupingMode([options.GROUP_BY_FOLDER],1);
            query.setFolders([bookmarksService.bookmarksMenuFolder], 1);

            var result = historyService.executeQuery(query, options);
            var rootNode = result.root;
            rootNode.containerOpen = true;
            yDebug.print("Child: " + rootNode.childCount, YB_LOG_MESSAGE);
            // iterate over the immediate children of this folder and dump to console
            for (var i = 0; i < rootNode.childCount; i ++) {
              var node = rootNode.getChild(i);
              yDebug.print("Child: " + node.itemId+" uri: "+node.uri, YB_LOG_MESSAGE);
                if(node.uri.indexOf("place:folder") == -1) bookmarksService.removeItem(node.itemId);
            }

            // close a container after using it!
            rootNode.containerOpen = false;
        }
        catch(e) {
            yDebug.print("ybookmarksOverlay.js::yb_restoreBookmarksToPlaces:: Exception - "+e, YB_LOG_MESSAGE);
        }

        /**
         * Hide sidebar
         */
        var sidebar = document.getElementById("sidebar-box");
        if (!sidebar.hidden) {
            toggleSidebar('viewYBookmarksSidebar', false);
        }

        yDebug.print("ybookmarksOverlay.js::yb_restoreBookmarksToPlaces:: deleted all the automatically imported bookmarks from bookmarks.html", YB_LOG_MESSAGE);

        /**
         * Delete extra.rdf
         */
        var ds = Components.classes["@mozilla.org/file/directory_service;1"].
            createInstance(Components.interfaces.nsIProperties);
        var extraFile = ds.get("ProfD", Components.interfaces.nsIFile);
        extraFile.append("extra.rdf");
        if (extraFile.exists()) {
            extraFile.remove(false);
        }
        //in case the file is not deleted
        var localStoreService = Components.classes["@mozilla.org/ybookmarks-store-service;1"].
                getService(Components.interfaces.nsIYBookmarksStoreService);
        localStoreService.setLastUpdateTime("-1");

        yDebug.print("ybookmarksOverlay.js::yb_restoreBookmarksToPlaces:: removed extra.rdf", YB_LOG_MESSAGE);

        /**
         * Import bookmarks from backup file
         */
        var dirService =
            ( Components.classes[ "@mozilla.org/file/directory_service;1" ] ).getService(
                Components.interfaces.nsIProperties );
        var aFile =
            dirService.get( "ProfD", Components.interfaces.nsILocalFile );
        aFile.append( "bk_bookmarks.html" );
        if( aFile.exists() ) {
            var importer = Cc["@mozilla.org/browser/places/import-export-service;1"].
                       getService(Ci.nsIPlacesImportExportService);
            importer.importHTMLFromFile(aFile, true);
        }
           yDebug.print("ybookmarksOverlay.js::yb_restoreBookmarksToPlaces:: bookmarks imported from bookmarks_bk", YB_LOG_MESSAGE);
    }
    catch(e) {
        yDebug.print("ybookmarksOverlay.js::yb_restoreBookmarksToPlaces::Exception: "+e, YB_LOG_MESSAGE);
    }

}

var YbookmarkUpdateObserver = {

  _total: null,
  _prevdone: 0,
  _chunk: 0,
  _done: 0,
  __timer: null,
  _failCount: 0,
  _maxFailures: -1,

  get _timer() {
    if ( !this.__timer ) {
      this.__timer = Components.classes["@mozilla.org/timer;1"].createInstance( Components.interfaces.nsITimer );
    }
    return this.__timer;
  },
  _pgrMeter: null,

  notify: function(aTimer) {
    if ( !this._pgrMeter )
      this._pgrMeter = document.getElementById("ybookmark-progressmeter" ),

    this._pgrMeter.value = ( this._prevdone * 100 ) / this._total;
    this._prevdone += 2;
  },

  observe: function ( subject, topic, data ) {
    try {
    var pgrText = document.getElementById("ybookmark-progresstext" );
    var pgrMeter = document.getElementById("ybookmark-progressmeter" );
    var pgrStatus = document.getElementById("ybookmark-progress-statusbarpanel" );
    var strings = document.getElementById( "ybookmarks-strings" );
    if (! (pgrMeter)) {
      return;
    }
    if ( topic == "ybookmark.syncBegin" ) {

      if (data != "remove-bookmarks" && data != "remove-extra") {
         pgrStatus.collapsed = false;
         pgrText.collapsed = false;
         pgrMeter.collapsed = false;
         pgrMeter.value = "1";
         pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.downloading" );
         this._total = null;
         this._done = 0;
       }

    } else if ( topic == "ybookmark.syncDone" ) {

      if ( data == "no-update" ) {

        pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.downloaddone" );
        setTimeout( function() { pgrStatus.collapsed = true; pgrText.collapsed = true; pgrMeter.collapsed = true; }, 2000 );

      } else if ( data == "all-done" ) {

        this._timer.cancel();
        pgrMeter.value = "100";
        pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.downloaddone" );
        setTimeout( function() { pgrStatus.collapsed = true; pgrText.collapsed = true; pgrMeter.collapsed = true; }, 2000 );
      } else if (data == "sync-aborted") {
            pgrMeter.value = "100";
          var pgrText = document.getElementById("ybookmark-progresstext" );
          pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.downloadfail" );
          pgrText.collapsed = false;

          pgrStatus.collapsed = false;
          pgrText.collapsed = false;
          pgrMeter.collapsed = false;
          setTimeout( function() { pgrStatus.collapsed = true; pgrText.collapsed = true; pgrMeter.collapsed = true; }, 2000 );
      } else if (data == "sync-error") {
        this._failCount++;

        yDebug.print("Sync failed. Attempt #" + this._failCount);

        if (this._maxFailures == -1) {
          this._maxFailures =
            ybookmarksMain.prefs.getIntPref(
              "[e-mail]");
        }

        if (this._failCount < this._maxFailures) {
          this._timer.cancel();
          pgrMeter.value = "1";
          setTimeout( function() { ybookmarksMain.syncservice.sync(false); }, Y_SYNC_ATTEMPT_WAIT );
        } else {
          yDebug.print("Syncing failed repeatedly. Aborting");
          this._timer.cancel();
          pgrMeter.value = "100";
          pgrText.value = strings.getString( "extensions.ybookmarks.statusbar.downloadfail" );
          pgrStatus.collapsed = false;
          pgrText.collapsed = false;
          pgrMeter.collapsed = false;
          setTimeout( function() { pgrStatus.collapsed = true; pgrText.collapsed = true; pgrMeter.collapsed = true; }, 2000 );
        }
      }

    } else if ( topic == "ybookmark.syncInfo" ) {

      if ( data == "add-to-ds-begin" ) {
        if ( this._total ) {
          var mid = ( this._prevdone +  this._chunk / 2 );
          var value = (( 100 * mid ) / this._total);
          pgrMeter.value = value;
        }

      }  else if ( data == "add-to-ds-end" ) {
            if ( this._total ) {
              this._timer.cancel();
              var value = (( 100 * this._done ) / this._total);
              pgrMeter.value = value;
            }

      } else if ( data == "more-chunk" ) {

        pgrMeter.collapsed = false;
        // subject has first and chunk element assigned to it
        if ( subject && subject.wrappedJSObject ) {
          subject = subject.wrappedJSObject;
        }

        if ( !subject ) {
          return;
        }

        this._timer.cancel();
        this._total = subject.total;
        this._chunk = subject.chunk;
        this._prevdone = this._done;
        this._done += subject.chunk;
        this._timer.initWithCallback( this, 100, Components.interfaces.nsITimer.TYPE_REPEATING_SLACK );
      }

    } else if (topic == "ybookmark.forceRefresh") {
        if (window == ybookmarksUtils.getTopWindow()) {
          setTimeout(ybookmarksMain.forceRefresh, 500);
        }
    }
  } catch (e) {
    yDebug.print("YbookmarkUpdateObserver.observe(" + subject + ", " + topic + ", " + data + "): " + e, YB_LOG_MESSAGE);
  }
  }
};

/*function ybBookmarkMenuUpdater(menuElement) {
  this._menu = menuElement;
  return this;
}

ybBookmarkMenuUpdater.prototype = {

  _updateMenus: function() {
    ybookmarksMain.isBookmarkChanged =
        ybookmarksMain._is_recent_menu_update_required =
                ybookmarksMain._is_frequent_menu_update_required =
                  ybookmarksMain._is_recently_saved_menu_update_required = true;

//    ybookmarks_Main.addBookmarksToPopup(
//                      document.getElementById( "ybookmarks_rc_visited_pop" ),
//                      "bookmark-sort-tree-visitdate-col" );
//    ybookmarks_Main.addBookmarksToPopup(
//                      document.getElementById( "ybookmarks_fr_visited_pop" ),
//                      "bookmark-sort-tree-visitcount-col" );
//
//    ybookmarks_Main.addBookmarkItemsToMainMenu();

  },

  observe: function ( aSubject, aTopic, aData ) {

    if ( aTopic == "ybookmark.syncBegin" ) {
    } else if (aTopic == "ybookmark.syncDone") {
       switch (aData) {
         case "all-done":
         case "sync-error":
           this._updateMenus();
           ybookmarksMain.isChangingDatasource = false;
           break;
         case "add-to-ds-begin":
           ybookmarksMain.isChangingDatasource = true;
           break;
         case "add-to-ds-end":
           ybookmarksMain.isChangingDatasource = false;
           ybookmarksMain.rebuildTagsMenu();
           break;
         case "more-chunk":
         case "no-update":
           break;
       }
    }
  },

  onAssert: function(aDatasource, aSource, aPredicate, aTarget) {
    //yDebug.print ( "onAssert => " + aPredicate.Value );
    this._setCommonFlags( aDatasource, aPredicate );
  },

  onBeginUpdateBatch: function(aDatasource) {
  },

  onChange: function(aDatasource, aSource, aPredicate, aOldTarget, aNewTarget ) {

    aPredicate.QueryInterface ( Components.interfaces.nsIRDFResource );
    if ( aPredicate.EqualsNode( gYBrscName ) || aPredicate.EqualsNode( gYBrscGenTitle ) ) {
      ybookmarksMain.isBookmarkChanged = true;
    }

    if ( aPredicate.EqualsNode( gYBrscVisitCount ) && !aOldTarget.EqualsNode( aNewTarget ) ) {
      yDebug.print ( "Most frequent flag changed" );
      ybookmarksMain._is_frequent_menu_update_required = true;
    }

    if ( aPredicate.EqualsNode( gYBrscLastVisitDate ) && !aOldTarget.EqualsNode ( aNewTarget ) ) {
      yDebug.print ( "Most recent flag changed" );
      ybookmarksMain._is_recent_menu_update_required = true;
      ybookmarksMain.isBookmarkChanged = true;

      // change the most visited count here
      var bookmark = ybookmarksMain.gBookmarks.getBookmarkFromResource ( aSource );
      if ( bookmark ) {
        ybookmarksMain.gBookmarks.incrementVisitCount ( bookmark.url );
      }
    }
  },

  onEndUpdateBatch: function(aDatasource) {
    //yDebug.print ( "End of batch update" );
  },

  onMove: function(aDatasource, aOldSource, aNewSource, aPredicate, aTarget) {
  },

  onUnassert: function(aDatasource, aSource, aPredicate, aTarget) {
    //yDebug.print ( "onUnassert => " + aPredicate.Value );
    this._setCommonFlags( aDatasource, aPredicate );
  },

  _setCommonFlags: function(aDatasource, aPredicate ) {
    if (aPredicate.EqualsNode( gYBrscTagValue ) ) {
      ybookmarksMain.isNewTagAdded = true;
    } else if ( aPredicate.EqualsNode( gYBrscUrl ) ) {
      ybookmarksMain.isBookmarkChanged = true;
      //for adding and deleting bookmarks, just in case the bookmarks are on these menus
      ybookmarksMain._is_frequent_menu_update_required = true;
      ybookmarksMain._is_recent_menu_update_required = true;
      ybookmarksMain._is_recently_saved_menu_update_required = true;
    } else if ( aPredicate.EqualsNode( gYBrscTag ) ) {
      ybookmarksMain.isBookmarkChanged = true;
    }
  }
};
*/
/**
 * Object that observes the extension manager for any changes in the state of
 * an extension. It's used to detect when this extension is being uninstalled
 * or disabled by the user.
 */
var yUninstallObserver = {
   /* indicates whether the extension is set to be uninstalled. */
   _uninstall : false,
   /* cached copy of the bookmarks store. */
   _bmStore: null,

   /**
    * Observes any changes in a particular "topic". In this case we're observing
    * changes in the extension manager and closing the application.
    * @param subject the object that experienced the change.
    * @param topic the topic being observed.
    * @param data the data relating to the change.
    */
   observe : function(subject, topic, data) {
      var wm =
         Components.classes["@mozilla.org/appshell/window-mediator;1"].
            getService(Components.interfaces.nsIWindowMediator);
      var winEnumerator = wm.getEnumerator("navigator:browser");
      /* this guarantees that having multiple windows won't cause problems. */
      var isFirstWindow = (winEnumerator.getNext() == window);

      if (topic == "em-action-requested" && isFirstWindow) {
         subject.QueryInterface(Components.interfaces.nsIUpdateItem);

         if (subject.id == YBOOKMARKS_ID) {
            if (data == "item-uninstalled") {
                this._uninstall = true;
                var syncService = Components.classes[Y_kSyncServiceContractID].
                    getService(Components.interfaces.nsIYBookmarkSyncService);
                syncService.cancelSync();
            } else if (data == "item-cancel-action") {
               /* uninstall and disable may be cancelled by selecting "Enable"
                  from the context menu. */
               this._uninstall = false;
            }
         }
      } else if (topic == "quit-application-granted") {
         if (this._uninstall) {
            /* unset all preferences we won't need later. */
            var count = {value: 0};
            var prefsToClean =
               ybookmarksMain.prefs.getChildList(
                  "extensions.ybookmarks@yahoo", count);

            for (var i = 0; i < count.value; i++) {
               if(ybookmarksMain.prefs.prefHasUserValue(prefsToClean[i])) {
                  ybookmarksMain.prefs.clearUserPref(prefsToClean[i]);
               }
            }
         }

         this.unregister();
      }
   },

   /**
    * Registers the observer to check for extension update and application exit
    * events.
    * @strings string bundle used for the dialog.
    */
   register: function() {
      var observerService =
         Components.classes["@mozilla.org/observer-service;1"].
            getService(Components.interfaces.nsIObserverService);

      observerService.addObserver(this, "em-action-requested", false);
      observerService.addObserver(this, "quit-application-granted", false);
   },

   /**
    * Unregisters the observer.
    */
   unregister: function() {
      var observerService =
        Components.classes["@mozilla.org/observer-service;1"].
           getService(Components.interfaces.nsIObserverService);

      observerService.removeObserver(this,"em-action-requested");
      observerService.removeObserver(this,"quit-application-granted");
   }
};

var ybInfoPanel = {
  _storeService: null,
  _bookmarkRdfObserver: null,

  register: function() {
    var infoIcon = document.getElementById("yb-statusbar-infopanel-icon");
    infoIcon.addEventListener("click", ybInfoPanel.infoOnClick, true);

    // TODO: we should actually use http://www.xulplanet.com/references/xpcomref/ifaces/nsIWebProgressListener.html
    // to support checking this BEFORE the page is loaded
    window.addEventListener("pageshow", ybInfoPanel.onPageShow, true);
    window.addEventListener("pagehide", ybInfoPanel.onPageHide, true);

    var tabBrowser = document.getElementById("content");
    tabBrowser.addEventListener("select", ybInfoPanel.onPageShow, true);

    this._bookmarkRdfObserver = {

      _ybInfoPanel: this,
      _shouldUpdate : false,
      _syncing : false,

      _update : function () {
        //fixed scope problem
        if (this != ybInfoPanel._bookmarkRdfObserver) {
          ybInfoPanel._bookmarkRdfObserver._update();
        }

        if (this._shouldUpdate) {
          if (this._syncing) {
            setTimeout(this._update, 2000);
            return;
          }

          this._shouldUpdate = false;
          this._ybInfoPanel.onPageShow();
        }
      },

      observe: function ( aSubject, aTopic, aData ) {
            if ( aTopic == "ybookmark.syncBegin" ) {
              this._syncing = true;

            } else if ( aTopic == "ybookmark.syncDone" ) {
              this._syncing = false;

              if ( aData == "all-done" || aData == "add-to-ds-end" || aData == "remove-bookmarks" || aData == "remove-extra") {
                 this._ybInfoPanel.onPageShow();
              }

            } else if (aTopic == "ybookmark.syncInfo") {
              if ( aData =="more-chunk" ) {
                // probably wait for whole update to finish
              }
            }

      },

      onAssert: function(aDatasource, aSource, aPredicate, aTarget) {
        if (this._syncing && this._shouldUpdate) {
          return;
        }

        //do it when a tag is added to a bookmark
        if ( aPredicate.EqualsNode( gYBrscUrl ) ) {
          aTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
          if (aTarget.Value == window.content.document.location) {
              this._shouldUpdate = true;
              setTimeout(this._update, 0);
          }
        }
      },

      onBeginUpdateBatch: function(aDatasource) {
      },

      onChange: function(aDatasource, aSource, aPredicate, aOldTarget, aNewTarget ) {
      },

      onEndUpdateBatch: function(aDatasource) {
      },

      onMove: function(aDatasource, aOldSource, aNewSource, aPredicate, aTarget) {
      },

      onUnassert: function(aDatasource, aSource, aPredicate, aTarget) {

        if (this._syncing && this._shouldUpdate) {
          return;
        }
        if ( aPredicate.EqualsNode( gYBrscUrl )) {
          aTarget.QueryInterface(Components.interfaces.nsIRDFLiteral);
          if (aTarget.Value == window.content.document.location) {
              this._shouldUpdate = true;
              setTimeout(this._update, 0);
          }
        }
      }
    };

    var os = Components.classes["@mozilla.org/observer-service;1"]
                                     .getService(Components.interfaces.nsIObserverService);
    os.addObserver ( this._bookmarkRdfObserver, "ybookmark.syncBegin", false );
    os.addObserver ( this._bookmarkRdfObserver, "ybookmark.syncInfo", false );
    os.addObserver ( this._bookmarkRdfObserver, "ybookmark.syncDone", false );

    this._storeService = Components.classes["@mozilla.org/ybookmarks-store-service;1"].
      getService(Components.interfaces.nsIYBookmarksStoreService);
    this._storeService.getDataSource().AddObserver( this._bookmarkRdfObserver );

  },

  unregister: function() {
    try {
      window.removeEventListener("pageshow", ybInfoPanel.onPageShow, true);
      window.removeEventListener("pagehide", ybInfoPanel.onPageHide, true);
    } catch ( e ) {
      yDebug.print("ybInfoPanel.unregister():" + e);
    }

    try {
      var tabBrowser = document.getElementById("content");
      tabBrowser.removeEventListener("select", ybInfoPanel.onPageShow, true);
    } catch ( e ) {
      yDebug.print("ybInfoPanel.unregister():" + e);
    }

    try {
      var infoIcon = document.getElementById("yb-statusbar-infopanel-icon");
      infoIcon.removeEventListener("click", ybInfoPanel.infoOnClick, true);
    } catch ( e ) {
      yDebug.print("ybInfoPanel.unregister():" + e);
    }

    try {
      this._storeService.getDataSource().RemoveObserver( this._bookmarkRdfObserver );
    } catch ( e ) {
      yDebug.print("ybInfoPanel.unregister():" + e);
    }

    try {
      var os = Components.classes["@mozilla.org/observer-service;1"]
                                       .getService(Components.interfaces.nsIObserverService);

      os.removeObserver ( this._bookmarkRdfObserver, "ybookmark.syncDone" );
      os.removeObserver ( this._bookmarkRdfObserver, "ybookmark.syncInfo" );
      os.removeObserver ( this._bookmarkRdfObserver, "ybookmark.syncBegin" );
    } catch ( e ) {
      yDebug.print("ybInfoPanel.unregister():" + e);
    }

  },


  onPageShow: function(event) {
    try {
      if (!window.content) { return; }
      var url = window.content.document.location;
      if (!url) { return; }

      var storeService = Components.classes["@mozilla.org/ybookmarks-store-service;1"].
          getService(Components.interfaces.nsIYBookmarksStoreService);
      var bookmark = storeService.isBookmarked(url);
      var infoPanel = document.getElementById("yb-statusbar-infopanel");
      var infoIcon = document.getElementById("yb-statusbar-infopanel-icon");

      if (bookmark) {
        var strings = document.getElementById("ybookmarks-strings");
        infoPanel.setAttribute("collapsed", false);
        infoIcon.setAttribute("collapsed", false);
        infoIcon.setAttribute("url", url);
      } else {
        infoPanel.setAttribute("collapsed", true);
        infoIcon.setAttribute("collapsed", true);
      }
    } catch (e) {
      yDebug.print("ybInfoPanel.onPageShow(): " + e);
    }
  },

  onPageHide: function(event) {
    try {
      if (window.content && event.target == window.content.document) {
        var infoPanel = document.getElementById("yb-statusbar-infopanel");
        var infoIcon = document.getElementById("yb-statusbar-infopanel-icon");
        infoPanel.setAttribute("collapsed", true);
        infoIcon.setAttribute("collapsed", true);
      }
    } catch(e) {
      yDebug.print("ybInfoPanel.onPageHide():" + e);
    }
  },

  infoOnClick: function (event) {
    var mouseClick = (event.button == 1) ? true : false;
    ybookmarksMain.loadRelevantPage(event, 'moreabout', mouseClick);
  },

  onTooltipShowing: function() {
    try {
      var url = document.getElementById("yb-statusbar-infopanel-icon").getAttribute("url");
      if (!url) { return; }

      var tags = document.getElementById("yb-statusbar-infopanel-tooltip-tags");
      var lastModified = document.getElementById("yb-statusbar-infopanel-tooltip-lastmodified");
      var notShared = document.getElementById("yb-statusbar-infopanel-tooltip-notshared");
      var notes = document.getElementById("yb-statusbar-infopanel-tooltip-notes");
      var notesLabel = document.getElementById("yb-statusbar-infopanel-tooltip-notes-label");

      var bookmark = Components.classes["@mozilla.org/ybookmarks-store-service;1"].
              getService(Components.interfaces.nsIYBookmarksStoreService).getBookmark(url);
      var strings = document.getElementById("ybookmarks-strings");

      var tagsEnum = bookmark.tags.enumerate();
      var jsTags = [];
      while( tagsEnum.hasMoreElements() ) {
        jsTags.push( (tagsEnum.getNext().QueryInterface( Components.interfaces.nsISupportsString ) ).data);
      }

      tags.setAttribute("value", jsTags.join(" "));

      lastModified.setAttribute("value", ybookmarksUtils.usecToUIString(bookmark.last_modified));
      if (bookmark.description) {
        notes.setAttribute("value", bookmark.description);
        notes.setAttribute("hidden", false);
        notesLabel.setAttribute("hidden", false);
      } else {
        notes.setAttribute("hidden", true);
        notesLabel.setAttribute("hidden", true);
      }
      //notes.appendChild(document.createTextNode(bookmark.description));

      if (bookmark.shared == "true") {
        notShared.setAttribute("hidden", true);
      } else {
        notShared.setAttribute("hidden", false);
      }

   } catch(e) {
     yDebug.print("tbInfoPanel.onTooltipShowing(): " + e);
   }
 }

};

var ybUserInterface = {

  _prefs: null,
  _strings: null,

  register: function(attribute){
    this._prefs = Components.classes["@mozilla.org/preferences-service;1"]
                    .getService(Components.interfaces.nsIPrefBranch);
    this._prefs.QueryInterface(Components.interfaces.nsIPrefBranch2);
    this._prefs.addObserver("[e-mail]", this.prefsObserver, false);

    this._strings = document.getElementById( "ybookmarks-strings" );
  },

  unregister: function(attribute){
    this._prefs.removeObserver("[e-mail]", this.prefsObserver);
  },

  prefsObserver: {
    observe : function(subject, topic, data) {
      if (data == "[e-mail]") {
        var hideUI = ybUserInterface._prefs.getBoolPref("[e-mail]");
        var remap = ybUserInterface._prefs.getBoolPref("[e-mail]");

        ybUserInterface.tweakBookmarksUI(hideUI);
        ybUserInterface.tweakKeyBindings(remap);
      } else if (data == "[e-mail]") {
        var remap = ybUserInterface._prefs.getBoolPref("[e-mail]");
        ybUserInterface.tweakKeyBindings(remap);
      }
    }
  },

  setHideUI: function (hide) {
    hide = hide ? true : false;
    this._prefs.setBoolPref("[e-mail]", hide);
  },

  setRemapKeyBindings: function(remap) {
    remap = remap ? true : false;
    this._prefs.setBoolPref("[e-mail]", remap);
  },

  /*
   * Currently, we keep the "intended" bindings for add and sidebar in the locale files.
   * We then backup and keybindings with yb_backup_*.  The secondary bindings are kept in
   * the preferences
   */
  tweakKeyBindings: function(remap) {
    try {
      var keyOrigAddBookmark = document.getElementById("addBookmarkAsKb");
      var keyOrigSidebar = document.getElementById("viewBookmarksSidebarKb");

      var keyDelAddBookmark = document.getElementById("addYBookmarkAsKb");
      var keyDelSidebar = document.getElementById("key_openYBookmarksSidebar");

      var secAddKey = this._prefs.getCharPref("[e-mail]");
      var secAddModifiers = this._prefs.getCharPref("[e-mail]");
      var secSidebarKey = this._prefs.getCharPref("[e-mail]");
      var secSidebarModifiers = this._prefs.getCharPref("[e-mail]");

      if (!keyDelSidebar) { return; }

      var hideUI = this._prefs.getBoolPref("[e-mail]");

      var safeBackup = function(elt, attrname) {
        var backup_attr = elt.getAttribute("yb_backup_" + attrname);
        if (!backup_attr) {
          elt.setAttribute("yb_backup_" + attrname, elt.getAttribute("attrname"));
        }
      };

      var safeRestore = function (elt, attrname) {
        var backup_attr = elt.getAttribute("yb_backup_" + attrname);
        if (backup_attr) {
          elt.setAttribute(attrname, backup_attr);
          return true;
        }
        return false;
      };

      var safeSetKeybinding = function (key, secAddKey, secAddModifiers) {
        if(!secAddKey) {
          secAddKey = "\n";  // bad hack. hope this doesn't break anything. "" is the famous "any Key"
        }
        safeBackup(key, "key");
        safeBackup(key, "modifiers");
        key.setAttribute("key", secAddKey);
        key.setAttribute("modifiers", secAddModifiers);
      };

      var safeResetKeybinding = function(key) {
        safeRestore(key, "key");
        safeRestore(key, "modifiers");
      };

        if (hideUI || remap) {
          safeResetKeybinding(keyDelSidebar);
          safeResetKeybinding(keyDelAddBookmark);
          safeSetKeybinding(keyOrigAddBookmark, secAddKey, secAddModifiers);
          safeSetKeybinding(keyOrigSidebar, secSidebarKey, secSidebarModifiers);
          yDebug.print("Remapping keybindings");

        } else {
          safeResetKeybinding(keyOrigSidebar);
          safeResetKeybinding(keyOrigAddBookmark);
          safeSetKeybinding(keyDelAddBookmark, secAddKey, secAddModifiers);
          safeSetKeybinding(keyDelSidebar, secSidebarKey, secSidebarModifiers);
          yDebug.print("Not remapping keybindings");
        }
    } catch (e) {
      yDebug.print("ybUserInterface.tweakKeyBindings():" + e);
    }

  },

  tweakBookmarksUI: function(hideUI) {
    //This is to work around a crash in Leopard.
    if(ybookmarksUtils.isOSXLeopard()) {
       //Hide these menu items
       var showBookmarksMenu = document.getElementById("yb-broadcaster-bookmarksmenu-show");
       var hideBookmarksMenu = document.getElementById("yb-broadcaster-bookmarksmenu-hide");
       showBookmarksMenu.setAttribute("hidden", true);
       hideBookmarksMenu.setAttribute("hidden", true);
       return;
    }
    try {
     hideUI = hideUI ? true : false;

        if(ybookmarksUtils.getFFMajorVersion() > 2) {
          bookmarksMenuId = "bookmarksMenu";
          bookmarksMenuPopup = "bookmarksMenuPopup";
      }
      else {
          bookmarksMenuId = "bookmarks-menu";
          bookmarksMenuPopup = "menu_BookmarksPopup";
      }

     var bookmarksMenu = document.getElementById(bookmarksMenuId);
     if (bookmarksMenu) {
        //This has some problem in OSX Leopard
        bookmarksMenu.setAttribute('hidden', hideUI);
     }



    var frame = document.getElementById("frame");
    if (frame) {
    var frameMenu = frame.childNodes[0];
    var oldItem = frameMenu.childNodes[6]; // Bookmark This Frame...

      // hide the contentAreaContextMenu items
      // hidden and collapsed are necc because normal context menu functionality futzes with hidden
      var bmLink = document.getElementById("context-bookmarklink");
      bmLink.hidden = hideUI;
      bmLink.collapsed = hideUI;
      var bmPage = document.getElementById("context-bookmarkpage");
      bmPage.hidden = hideUI;
      bmPage.collapsed = hideUI;

      oldItem.hidden = hideUI;
      oldItem.collapsed = hideUI;

      bmThisFrame = document.getElementById("yb_bookmark_this_frame_item");
      if (!bmThisFrame) {
        var bookmarkFrameItem = document.createElement("menuitem");
        bookmarkFrameItem.setAttribute("id", "yb_bookmark_this_frame_item");
        bookmarkFrameItem.setAttribute("label", this._strings.getString("extensions.ybookmarks.context.bookmark.frame"));
        bookmarkFrameItem.setAttribute("command", "cmd_yb_bookmark_this_frame");
        bookmarkFrameItem.setAttribute("class", "menuitem-iconic");
        bookmarkFrameItem.setAttribute("image", "chrome://ybookmarks/skin/delicious_context.png");
        frameMenu.insertBefore(bookmarkFrameItem, oldItem.nextSibling);
      }

    }
      //bookmarks menu
        var bookmarksMenuPopup = document.getElementById(bookmarksMenuPopup);
        if (!bookmarksMenuPopup.ybTweaked) {
          // we need to add and remove the items because of the bookmarks templates messes up the separator
        bookmarksMenuPopup.setAttribute("onpopupshowing", " if (event.target == this) { ybookmarksMain.onBookmarksMenuPopupShowing(event);}" + bookmarksMenuPopup.getAttribute("onpopupshowing"));
        bookmarksMenuPopup.ybTweaked = true;
      }

      var tabbrowser = getBrowser();
      var tabMenu = document.getAnonymousElementByAttribute(tabbrowser,"anonid","tabContextMenu");
      //Show/Hide Our Mainu Menu for Bookmarks "Show Bookmarks Menu" and "Hide Bookmarks Menu"
      //:::Classic mode doesnt need this.Coz we dont hide or show bookmarks menu.
        if(ybookmarksUtils.getExtensionMode() == YB_EXTENSION_MODE_STANDARD)  {
          var showBookmarksMenu = document.getElementById("yb-broadcaster-bookmarksmenu-show");
          var hideBookmarksMenu = document.getElementById("yb-broadcaster-bookmarksmenu-hide");
          showBookmarksMenu.setAttribute("hidden", !hideUI);
          hideBookmarksMenu.setAttribute("hidden", hideUI);
        }

      if (tabMenu && !tabMenu.ybTweaked) {
        var insertPos = tabMenu.lastChild.previousSibling;
        var ffbmAll = null;
        var ffbmCur = null;
        var tabContextMenuItem = insertPos.previousSibling;
        while(tabContextMenuItem && (!ffbmAll || !ffbmCur)) {
            if (tabContextMenuItem.getAttribute("command") == "Browser:BookmarkAllTabs") {
                ffbmAll = tabContextMenuItem;
            } else if (tabContextMenuItem.getAttribute("oncommand") == "BookmarkThisTab();") {
                ffbmCur = tabContextMenuItem;
            }
            tabContextMenuItem = tabContextMenuItem.previousSibling;
        }

        if (ffbmAll) {
          ffbmAll.hidden = hideUI;
          ffbmAll.collapsed = hideUI;
        }
        if (ffbmCur) {
          ffbmCur.hidden = hideUI;
          ffbmCur.collapsed = hideUI;
        }
        var hideYBContextMenu = false;
        try  {
            hideYBContextMenu = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch).getBoolPref("[e-mail]");
        } catch(e) {
            yDebug.print("Exception while accessing user preference:" + e);
        }
        //Adding our menu in the tabmenu
        if(!hideYBContextMenu) {
            var bookmarkCurTabItem = document.createElement("menuitem");
            bookmarkCurTabItem.setAttribute("label", this._strings.getString("extensions.ybookmarks.context.bookmark.tab"));
            bookmarkCurTabItem.setAttribute("oncommand", "ybookmarksMain.bookmarkThisTab();");
            tabMenu.insertBefore(bookmarkCurTabItem, insertPos);
        }
        tabMenu.ybTweaked = true;
      }
    } catch (e) {
      yDebug.print("ybUserInterface.tweakBookmarksUI(): " + e);
    }
   },

   switchToStandardMode: function() {
           var params = {out:null};
           window.openDialog("chrome://ybookmarks/content/switchToRegMode.xul", "", "chrome,dialog,centerscreen,modal,resizable=no", params);
           if(params.out) {
               //set the mode pref value and restart.
            var pref = Components.classes["@mozilla.org/preferences-service;1"].
                     getService(Components.interfaces.nsIPrefBranch);
            pref.setCharPref("[e-mail]", YB_EXTENSION_MODE_STANDARD);
               ybookmarksUtils.restartBrowser();
           }
           return true;
   }
};

/* End - Add Bookmark Call Backs */
/* Helper functions */
function yb_onLoad(event) {
  try {
     ybookmarksMain.onLoad(event);
  } catch (e) {
     yDebug.print("Uncaught error during onload:" + e.message + (e.stack ? e.stack : ""), YB_LOG_MESSAGE);
     throw e;
  }
}

function yb_onUnload(event) {
  try {
     ybookmarksMain.onUnload(event);
  } catch (e) {
     yDebug.print("Uncaught error during unload:" + e.message + (e.stack ? e.stack : ""), YB_LOG_MESSAGE);
     throw e;
  }
}
/* End of Helper functions */

/**
 * Listner class for adress bar changes to provide data for tagometer
 */
var urlBarListenerFavIcon = {
  onLocationChange: function() {},
  onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus) {
    const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
    if (aStateFlags & nsIWebProgressListener.STATE_STOP) {
      if (aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK) {
        if (aWebProgress.DOMWindow == content) {
          var browser = gBrowser.mCurrentBrowser;
          if (!gBrowser.mTabbedMode && !browser.mIconURL)
            gBrowser.useDefaultIcon(gBrowser.mCurrentTab);
          if (browser.mIconURL) {

              gYB_loadFavIconNew(browser.currentURI.spec, browser.mIconURL);

          }
        }
      }
    }
  },
  onProgressChange: function() {},
  onStatusChange: function() {},
  onSecurityChange: function() {},
  onLinkIconAvailable: function() {}
};

window.addEventListener("load",
                          yb_onLoad,
                          false);
window.addEventListener("unload",
                          yb_onUnload,
                          false);